coderio 0.4.0__py3-none-any.whl

coderio/tools/edit_file.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+_LINE_PREFIX_RE = re.compile(r"^\s*\d+\s*?\t")
+
+
+class EditFileArgs(BaseModel):
+    path: str = Field(description="Path to the file to edit.")
+    old_string: str = Field(description="Exact text to replace (must match uniquely unless replace_all).")
+    new_string: str = Field(description="Text to substitute in place of old_string.")
+    replace_all: bool = Field(default=False, description="Replace every occurrence.")
+
+
+def _strip_line_prefix(text: str) -> str:
+    """Strip read_file's 'N\\t' line-number prefix from each line (spec §3.2)."""
+    return "\n".join(
+        _LINE_PREFIX_RE.sub("", line) if _LINE_PREFIX_RE.match(line) else line for line in text.splitlines()
+    )
+
+
+class EditFileTool:
+    name = "edit_file"
+    description = (
+        "Exact string replacement in a file. old_string must match uniquely unless "
+        "replace_all is true. Requires permission in confirm/plan modes."
+    )
+    args_schema = EditFileArgs
+
+    def run(self, path: str, old_string: str, new_string: str, replace_all: bool = False) -> str:
+        p = Path(path)
+        if not p.is_file():
+            return f"Error: file not found: {path}"
+        text = p.read_text(encoding="utf-8", errors="replace")
+        old_string = _strip_line_prefix(old_string)
+        new_string = _strip_line_prefix(new_string)
+        # Empty old_string is a footgun: str.replace("", x) inserts x between
+        # every character (len(text)+1 insertions), producing catastrophic
+        # bloat. Reject explicitly — the caller has a bug.
+        if not old_string:
+            return "Error: old_string is empty; provide the exact text to replace"
+        count = text.count(old_string)
+        if count == 0:
+            return f"Error: old_string not found in {path}"
+        if count > 1 and not replace_all:
+            return f"Error: old_string matches {count} times (not unique); set replace_all=true"
+        if replace_all:
+            new_text = text.replace(old_string, new_string)
+        else:
+            new_text = text.replace(old_string, new_string, 1)
+        p.write_text(new_text, encoding="utf-8")
+        return f"Edited {path}: replaced {count if replace_all else 1} occurrence(s)"

coderio/tools/glob_tool.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class GlobArgs(BaseModel):
+    pattern: str = Field(description="Glob pattern (e.g. '**/*.py' to recurse).")
+    path: str = Field(default=".", description="Base directory to search in.")
+
+
+class GlobTool:
+    name = "glob"
+    description = "Match files by glob pattern (e.g. **/*.py). Returns matching paths."
+    args_schema = GlobArgs
+
+    def run(self, pattern: str, path: str = ".") -> str:
+        base = Path(path)
+        matches = sorted(str(p) for p in base.glob(pattern))
+        return "\n".join(matches) if matches else "No matches"

coderio/tools/grep_tool.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class GrepArgs(BaseModel):
+    pattern: str = Field(description="Regex pattern to search for.")
+    path: str = Field(default=".", description="File or directory to search in.")
+    glob: str = Field(default="", description="Optional glob filter (e.g. '*.py').")
+    output_mode: str = Field(
+        default="content",
+        description="'content' (lines), 'files_with_matches' (paths), or 'count'.",
+    )
+
+
+def _rg_available() -> bool:
+    return shutil.which("rg") is not None
+
+
+class GrepTool:
+    name = "grep"
+    description = (
+        "Search file contents by regex. Uses ripgrep if available, else Python fallback. "
+        "output_mode: 'content' (default), 'files_with_matches', or 'count'."
+    )
+    args_schema = GrepArgs
+
+    def run(
+        self,
+        pattern: str,
+        path: str = ".",
+        glob: str = "",
+        output_mode: str = "content",
+    ) -> str:
+        if _rg_available():
+            return self._with_rg(pattern, path, glob, output_mode)
+        return self._python_fallback(pattern, path, glob, output_mode)
+
+    def _with_rg(self, pattern: str, path: str, glob: str, output_mode: str) -> str:
+        cmd = ["rg", "--no-heading", "-n"]
+        mode_map = {"content": "", "files_with_matches": "-l", "count": "-c"}
+        flag = mode_map.get(output_mode, "")
+        if flag:
+            cmd.append(flag)
+        if glob:
+            cmd += ["--glob", glob]
+        cmd += [pattern, path]
+        try:
+            proc = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8", errors="replace")
+            return (proc.stdout or "").strip() or "No matches"
+        except FileNotFoundError:
+            return self._python_fallback(pattern, path, glob, output_mode)
+
+    def _python_fallback(self, pattern: str, path: str, glob: str, output_mode: str) -> str:
+        base = Path(path)
+        if glob:
+            files = list(base.rglob(glob))
+        else:
+            files = list(base.rglob("*"))
+        rx = re.compile(pattern)
+        content_hits = []
+        matched_files = []
+        total = 0
+        for f in files:
+            if not f.is_file():
+                continue
+            try:
+                text = f.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                continue
+            file_count = 0
+            for i, line in enumerate(text.splitlines(), 1):
+                if rx.search(line):
+                    total += 1
+                    file_count += 1
+                    if output_mode == "files_with_matches":
+                        matched_files.append(str(f))
+                        break
+                    elif output_mode == "content":
+                        content_hits.append(f"{f}:{i}:{line}")
+        if output_mode == "count":
+            return f"{total} matches"
+        if output_mode == "files_with_matches":
+            return "\n".join(matched_files) if matched_files else "No matches"
+        return "\n".join(content_hits) if content_hits else "No matches"

coderio/tools/linux_sandbox.py

@@ -0,0 +1,196 @@
+"""Linux sandboxing via bubblewrap (bwrap).
+
+bubblewrap uses Linux user namespaces to provide a lightweight sandbox without
+requiring root or a container runtime. It's the same tool Claude Code uses on
+Linux, and Flatpak's underlying sandbox.
+
+What this isolates (in "write" mode):
+  - **File writes**: the sandboxed process sees the root filesystem read-only;
+    only the workspace dir is mounted read-write. Writes outside the workspace
+    fail at the filesystem (mount) level — not a regex check, an actual EROFS.
+  - **Network**: optionally disabled via ``--unshare-net`` (network namespace).
+
+Availability: requires ``bwrap`` installed (``apt install bubblewrap`` on Debian
+/ Ubuntu, standard on Fedora). Some distros disable unprivileged user
+namespaces by default (RHEL, older Debian) — in that case bwrap fails and we
+fall back to plain subprocess.
+
+Unlike the Windows path, this is a TRUE sandbox in v1 (bubblewrap's namespace
+isolation is complete, not "prepared but not applied"). The gap vs. Windows
+reflects the platform maturity: bubblewrap is battle-tested (Flatpak), while
+the Windows Restricted Token path needs more wiring (see win_sandbox.py).
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+_log = logging.getLogger(__name__)
+
+
+def bwrap_available() -> bool:
+    """Check if bubblewrap is installed and functional.
+
+    Returns True only if the ``bwrap`` binary is on PATH. We don't probe
+    unprivileged-userns support here (that requires actually running bwrap) —
+    the caller should handle a bwrap failure as a fallback signal.
+    """
+    if sys.platform == "win32":
+        return False  # bubblewrap is Linux-only
+    return shutil.which("bwrap") is not None
+
+
+def build_bwrap_args(
+    command: str,
+    workspace: str,
+    *,
+    network_allowed: bool = True,
+    fs_config=None,
+) -> list[str]:
+    """Build the bwrap argument list for a write-restricted sandbox.
+
+    Mount layout (default, no fs_config):
+      - ``/`` read-only (system libraries readable, no writes).
+      - ``workspace`` read-write (the only writable path).
+      - ``/dev``, ``/proc`` mounted (many tools need them; /dev is read-only).
+      - ``/tmp`` as a private tmpfs (writable but isolated).
+
+    Network: if ``network_allowed=False``, ``--unshare-net`` puts the process
+    in its own network namespace with only loopback — no external connectivity.
+
+    Filesystem config (Claude-Code-compatible four-tuple, when fs_config given):
+      - ``allow_write``: extra read-write mounts beyond workspace.
+      - ``deny_write``: read-only overrides (workspace subpaths forced read-only).
+      - ``deny_read``: tmpfs blackholes (path exists but contents invisible).
+      - ``allow_read``: read-only re-mounts that punch through a deny_read.
+    Paths support ``~`` (home) and ``./`` (workspace-relative) prefixes.
+    """
+    # Resolve workspace to an absolute path (bwrap requires it).
+    ws = str(Path(workspace).resolve())
+
+    args = [
+        "bwrap",
+        "--ro-bind",
+        "/",
+        "/",
+        "--bind",
+        ws,
+        ws,
+        "--dev",
+        "/dev",
+        "--proc",
+        "/proc",
+        "--tmpfs",
+        "/tmp",
+    ]
+    if not network_allowed:
+        args.append("--unshare-net")
+    # Filesystem four-tuple (Gap 3). Each path is expanded and appended in
+    # order; bwrap applies later mounts on top of earlier ones, so deny_read's
+    # tmpfs must come before allow_read's ro-bind to "punch a hole".
+    if fs_config is not None:
+        from pathlib import Path as _Path
+
+        home = _Path.home()
+        # allow_write: extra read-write mounts (e.g. /tmp/build, ~/.cache).
+        for p in getattr(fs_config, "allow_write", []) or []:
+            resolved = _resolve_fs_path(p, ws, home)
+            args += ["--bind", resolved, resolved]
+        # deny_write: read-only overrides (force a path read-only even if it
+        # would otherwise be writable, e.g. .git/hooks inside workspace).
+        for p in getattr(fs_config, "deny_write", []) or []:
+            resolved = _resolve_fs_path(p, ws, home)
+            args += ["--ro-bind", resolved, resolved]
+        # deny_read: tmpfs blackholes (path exists but is empty — hides the
+        # real contents, e.g. ~/.ssh appears as an empty dir).
+        for p in getattr(fs_config, "deny_read", []) or []:
+            resolved = _resolve_fs_path(p, ws, home)
+            args += ["--tmpfs", resolved]
+        # allow_read: read-only re-mounts that punch through a deny_read
+        # blackhole. MUST come after the deny_read tmpfs to take effect.
+        for p in getattr(fs_config, "allow_read", []) or []:
+            resolved = _resolve_fs_path(p, ws, home)
+            args += ["--ro-bind", resolved, resolved]
+    # Die if the child can't set up the namespace (don't silently run unsandboxed).
+    args.append("--die-with-parent")
+    # Finally, the command to run inside the sandbox.
+    args += ["--", "sh", "-c", command]
+    return args
+
+
+def _resolve_fs_path(path: str, workspace: str, home) -> str:
+    """Expand ~ and relative paths in a filesystem config entry.
+
+    - ``~/foo`` → ``{home}/foo``
+    - ``./foo`` or ``foo`` → ``{workspace}/foo`` (project-relative)
+    - ``/abs/path`` → unchanged
+    """
+    if path.startswith("~"):
+        return str((home / path[2:]).resolve()) if path.startswith("~/") else str(home.resolve())
+    if path.startswith("./"):
+        return str((Path(workspace) / path[2:]).resolve())
+    if not path.startswith("/"):
+        # Bare relative path → workspace-relative (same as ./).
+        return str((Path(workspace) / path).resolve())
+    return path
+
+
+def run_bwrap(
+    command: str,
+    cwd: str,
+    *,
+    timeout: int = 120,
+    env: dict | None = None,
+    max_output_bytes: int = 100_000,
+    network_allowed: bool = True,
+    fs_config=None,
+) -> tuple[int, str]:
+    """Run a command in a bubblewrap sandbox.
+
+    Returns (exit_code, combined_output). On bwrap failure (not installed,
+    userns disabled), the caller (sandbox_runner) falls back to plain subprocess.
+
+    Args:
+        network_allowed: if False, adds ``--unshare-net`` (own network namespace,
+            only loopback — no external connectivity). Prevents ``curl``/``wget``
+            in shell commands from exfiltrating data.
+        fs_config: optional SandboxFsConfig with allow_write/deny_write/deny_read/
+            allow_read lists for per-path filesystem isolation.
+    """
+    if not bwrap_available():
+        return (-1, "bubblewrap not installed")
+
+    args = build_bwrap_args(command, cwd, network_allowed=network_allowed, fs_config=fs_config)
+    try:
+        proc = subprocess.run(
+            args,
+            capture_output=True,
+            cwd=cwd,
+            timeout=timeout,
+            text=False,
+            stdin=subprocess.DEVNULL,
+            env=env,
+            start_new_session=True,  # own process group for reliable kill
+        )
+        stdout = proc.stdout.decode("utf-8", errors="replace") if proc.stdout else ""
+        stderr = proc.stderr.decode("utf-8", errors="replace") if proc.stderr else ""
+        # bubblewrap setup errors go to stderr — surface them so the model knows
+        # why the command failed (e.g. "bwrap: No support for user namespaces").
+        output = stdout
+        if stderr:
+            # On a successful run, bwrap's own stderr is empty — stderr content
+            # is either the command's stderr or a bwrap setup error. Include it.
+            output += f"\n[stderr]\n{stderr}"
+        if len(output) > max_output_bytes:
+            output = output[:max_output_bytes] + f"\n\n... Output truncated at {max_output_bytes} bytes."
+        return (proc.returncode, output)
+    except subprocess.TimeoutExpired:
+        return (124, f"Command timed out after {timeout}s (in bubblewrap sandbox)")
+    except FileNotFoundError:
+        return (-1, "bubblewrap binary not found at runtime")
+    except Exception as e:  # noqa: BLE001
+        return (-1, f"bubblewrap sandbox failed: {e}")

coderio/tools/list_dir.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+
+class ListDirArgs(BaseModel):
+    path: str = Field(description="Directory to list.")
+    recursive: bool = Field(default=False, description="Recurse into subdirectories.")
+    max_depth: int = Field(default=3, description="Max recursion depth (when recursive).")
+
+
+class ListDirTool:
+    name = "list_dir"
+    description = (
+        "List the contents of a directory. Returns file/dir names (directories marked "
+        "with a trailing /). Supports recursive listing with a max depth. Use to "
+        "understand project structure."
+    )
+    args_schema = ListDirArgs
+
+    def run(self, path: str, recursive: bool = False, max_depth: int = 3) -> str:
+        base = Path(path)
+        if not base.exists():
+            return f"Error: path not found: {path}"
+        if not base.is_dir():
+            return f"Error: not a directory: {path}"
+
+        lines = []
+
+        def _walk(d: Path, prefix: str, depth: int) -> None:
+            try:
+                entries = sorted(
+                    d.iterdir(),
+                    key=lambda p: (not p.is_dir(), p.name.lower()),
+                )
+            except OSError as e:
+                lines.append(f"{prefix}<error: {e}>")
+                return
+            for entry in entries:
+                if entry.name in {
+                    "__pycache__",
+                    "venv",
+                    ".venv",
+                    ".git",
+                    "node_modules",
+                }:
+                    continue
+                if entry.is_dir():
+                    lines.append(f"{prefix}{entry.name}/")
+                    if recursive and depth + 1 < max_depth:
+                        _walk(entry, prefix + "  ", depth + 1)
+                else:
+                    lines.append(f"{prefix}{entry.name}")
+
+        _walk(base, "", 0)
+        return "\n".join(lines) if lines else "(empty directory)"

coderio/tools/multi_edit.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+from coderio.tools.edit_file import _strip_line_prefix
+
+
+class _SingleEdit(BaseModel):
+    old_string: str = Field(description="Exact text to replace (must match uniquely unless replace_all).")
+    new_string: str = Field(description="Text to substitute.")
+    replace_all: bool = Field(default=False, description="Replace every occurrence.")
+
+
+class MultiEditArgs(BaseModel):
+    path: str = Field(description="Path to the file to edit.")
+    edits: list[_SingleEdit] = Field(description="Ordered list of edits to apply sequentially.")
+
+
+class MultiEditTool:
+    name = "multi_edit"
+    description = (
+        "Apply multiple exact-string edits to one file in a single call. Each edit sees "
+        "the result of the previous one. If any edit's old_string is not found (or is "
+        "ambiguous), the whole operation aborts with NO changes written. Requires "
+        "permission in confirm/plan modes."
+    )
+    args_schema = MultiEditArgs
+
+    def run(self, path: str, edits: list[dict]) -> str:
+        p = Path(path)
+        if not p.is_file():
+            return f"Error: file not found: {path}"
+        if not edits:
+            return "No edits provided; file unchanged."
+        text = p.read_text(encoding="utf-8", errors="replace")
+        applied = 0
+        for i, edit in enumerate(edits):
+            old = _strip_line_prefix(edit.get("old_string", ""))
+            new = _strip_line_prefix(edit.get("new_string", ""))
+            replace_all = edit.get("replace_all", False)
+            # Empty old_string is a footgun (see edit_file.py): str.replace("",
+            # x) inserts x between every character. Reject before it corrupts
+            # the file — multi_edit is atomic, so nothing is written yet.
+            if not old:
+                return (
+                    f"Error: edit #{i + 1} old_string is empty; provide the exact "
+                    "text to replace. Aborted (no changes written)."
+                )
+            count = text.count(old)
+            if count == 0:
+                return f"Error: edit #{i + 1} old_string not found in {path}; aborted (no changes written)."
+            if count > 1 and not replace_all:
+                return (
+                    f"Error: edit #{i + 1} old_string matches {count} times (not unique); "
+                    "set replace_all=true or make it unique. Aborted (no changes written)."
+                )
+            text = text.replace(old, new) if replace_all else text.replace(old, new, 1)
+            applied += 1
+        p.write_text(text, encoding="utf-8")
+        return f"Edited {path}: applied {applied} edit(s)"

coderio/tools/note.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from pydantic import BaseModel, Field
+
+_DEFAULT_NOTES_DIR = Path.home() / ".coderio" / "notes"
+
+
+class NoteArgs(BaseModel):
+    action: str = Field(description="One of: write, read, list, append, delete.")
+    name: str = Field(default="", description="Note name (becomes <name>.md).")
+    content: str = Field(default="", description="Note content (for write/append).")
+
+
+class NoteTool:
+    """Cross-session long-term memory. Notes persist in ~/.coderio/notes/<name>.md
+    and survive across REPL sessions, unlike session history."""
+
+    name = "note"
+    description = (
+        "Persistent notes for cross-session memory. actions: write/read/list/append/delete. "
+        "Notes are stored as markdown files and survive across sessions — use them to record "
+        "decisions, context, or TODOs you want to recall later."
+    )
+    args_schema = NoteArgs
+
+    def __init__(self, notes_dir: Path | str | None = None):
+        self._dir = Path(notes_dir) if notes_dir else _DEFAULT_NOTES_DIR
+
+    def _path(self, name: str) -> Path:
+        safe = "".join(c for c in name if c.isalnum() or c in "-_") or "untitled"
+        return self._dir / f"{safe}.md"
+
+    def run(self, action: str, name: str = "", content: str = "") -> str:
+        if action == "list":
+            self._dir.mkdir(parents=True, exist_ok=True)
+            notes = sorted(p.stem for p in self._dir.glob("*.md"))
+            if not notes:
+                return "No notes."
+            return "Notes:\n" + "\n".join(f"  - {n}" for n in notes)
+        elif action == "write":
+            if not name:
+                return "Error: name is required for write."
+            p = self._path(name)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            p.write_text(content, encoding="utf-8")
+            return f"Saved note: {p.stem}"
+        elif action == "read":
+            if not name:
+                return "Error: name is required for read."
+            p = self._path(name)
+            if not p.is_file():
+                return f"Note not found: {name}"
+            return p.read_text(encoding="utf-8", errors="replace")
+        elif action == "append":
+            if not name:
+                return "Error: name is required for append."
+            p = self._path(name)
+            p.parent.mkdir(parents=True, exist_ok=True)
+            existing = p.read_text(encoding="utf-8", errors="replace") if p.is_file() else ""
+            p.write_text(existing + content, encoding="utf-8")
+            return f"Appended to note: {p.stem}"
+        elif action == "delete":
+            if not name:
+                return "Error: name is required for delete."
+            p = self._path(name)
+            if p.is_file():
+                p.unlink()
+                return f"Deleted note: {p.stem}"
+            return f"Note not found: {name}"
+        return f"Error: unknown action {action!r}. Use: write/read/list/append/delete."