✨ Feat: Add file_reader and python tools

- Implemented a new FileReadTool for safely reading local text files.
- Added a PythonSandboxTool to execute Python snippets in a sandboxed environment.
- Updated the README.md to include the new tools and their descriptions.
- Registered both new tools in the load_default_tools function.

Author: PythonicNinja

README.md

@@ -59,6 +59,7 @@ Tools live under `simple_agent/tools` and implement a tiny interface (`name`, `d
 - `time`: returns the current UTC timestamp.
 - `calculator`: evaluates small arithmetic expressions safely.
 - `file_reader`: dumps a snippet of a local text file (`path[:start-end]`).
+- `python`: runs a short Python snippet in a separate interpreter (stdout/stderr returned).
 
 Adding new tools only requires dropping a module next to the others and including it in `load_default_tools()`.
 

simple_agent/tools/__init__.py

@@ -8,12 +8,13 @@
 from .file_read_tool import FileReadTool
 from .math_tool import MathTool
 from .time_tool import TimeTool
+from .python_tool import PythonSandboxTool
 
 
 def load_default_tools() -> List[Tool]:
     """Return the default toolset used by the CLI."""
 
-    return [TimeTool(), MathTool(), FileReadTool()]
+    return [TimeTool(), MathTool(), FileReadTool(), PythonSandboxTool()]
 
 
 __all__ = ["Tool", "load_default_tools"]

simple_agent/tools/file_read_tool.py

@@ -0,0 +1,86 @@
+"""Tool for reading snippets of local files safely."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .base import SimpleTool
+
+
+class FileReadTool(SimpleTool):
+    """Reads text files relative to the repo, optionally with a line range."""
+
+    def __init__(self, base_dir: Path | None = None, *, max_chars: int = 4000) -> None:
+        super().__init__(
+            name="file_reader",
+            description="Read a local text file. Format: 'path/to/file[:start-end]'.",
+        )
+        self.base_dir = Path(base_dir or Path.cwd()).resolve()
+        self.max_chars = max_chars
+
+    def run(self, query: str) -> str:
+        query = query.strip()
+        if not query:
+            return "Provide a relative path, optionally with :start-end for line numbers."
+
+        path_str, sep, range_str = query.partition(":")
+        target = (self.base_dir / path_str).resolve()
+
+        if not str(target).startswith(str(self.base_dir)):
+            return "Refusing to read outside the project directory."
+        if not target.exists():
+            return f"File not found: {path_str}"
+        if target.is_dir():
+            return f"'{path_str}' is a directory."
+
+        try:
+            text = target.read_text(encoding="utf-8", errors="replace")
+        except UnicodeDecodeError:
+            return "File does not appear to be UTF-8 text."
+
+        lines = text.splitlines()
+        snippet: str
+
+        if sep:
+            start_line, end_line = _parse_range(range_str)
+            if start_line is None:
+                return "Invalid range. Use integers like :10-30."
+            start_idx = max(start_line - 1, 0)
+            end_idx = end_line if end_line is not None else start_idx + 40
+            snippet_lines = lines[start_idx:end_idx]
+            snippet = "\n".join(snippet_lines)
+        else:
+            snippet = "\n".join(lines[:80])
+
+        snippet = snippet.strip()
+        if len(snippet) > self.max_chars:
+            snippet = f"{snippet[: self.max_chars]}…"
+
+        return f"{path_str}:\n{snippet or '(file empty)'}"
+
+
+def _parse_range(range_str: str) -> tuple[int | None, int | None]:
+    if not range_str:
+        return None, None
+    parts = range_str.split("-")
+    if len(parts) == 1:
+        try:
+            start = int(parts[0])
+        except ValueError:
+            return None, None
+        return start, start + 40
+
+    start_str, end_str = parts[0], parts[1]
+    try:
+        start = int(start_str) if start_str else 1
+    except ValueError:
+        return None, None
+    if end_str:
+        try:
+            end = int(end_str)
+        except ValueError:
+            return None, None
+    else:
+        end = start + 40
+
+    return start, end

simple_agent/tools/python_tool.py

@@ -0,0 +1,64 @@
+"""Sandboxed Python execution tool."""
+
+from __future__ import annotations
+
+import subprocess
+from textwrap import dedent
+
+from .base import SimpleTool
+
+
+class PythonSandboxTool(SimpleTool):
+    """Executes small Python snippets in a separate interpreter."""
+
+    def __init__(self, *, timeout: int = 5) -> None:
+        super().__init__(
+            name="python",
+            description="Run Python code in a sandboxed interpreter. Provide raw code; stdout is returned.",
+        )
+        self.timeout = timeout
+
+    def run(self, query: str) -> str:
+        code = query.strip()
+        if not code:
+            return "Provide Python code to run."
+
+        wrapped = dedent(
+            f"""
+            import sys
+
+            namespace = {{}}
+            code = {code!r}
+            try:
+                exec(code, namespace, namespace)
+            except SystemExit as exc:
+                print(f"[SystemExit] {{exc}}", file=sys.stderr)
+            except Exception as exc:  # pylint: disable=broad-except
+                print(f"[Error] {{exc}}", file=sys.stderr)
+            """
+        ).strip()
+
+        try:
+            completed = subprocess.run(
+                ["python3", "-c", wrapped],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                check=False,
+            )
+        except subprocess.TimeoutExpired:
+            return "Python execution timed out."
+        except Exception as exc:  # pylint: disable=broad-except
+            return f"Failed to invoke python: {exc}"
+
+        stdout = completed.stdout.strip()
+        stderr = completed.stderr.strip()
+
+        if completed.returncode != 0 and stderr:
+            return f"Python exited with {completed.returncode}: {stderr}"
+
+        if stderr and stdout:
+            return f"{stdout}\n[stderr]\n{stderr}"
+        if stderr:
+            return f"[stderr]\n{stderr}"
+        return stdout or "(no output)"