regcode 0.1.0__py3-none-any.whl

regcode/tools/builtins.py

@@ -0,0 +1,947 @@
+"""Built-in tools for the regcode agent.
+
+Provides tools for code execution, file operations, and system info
+using the Monty sandbox for secure, isolated Python execution.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Any
+
+from regcode.monty_sandbox import MontySandbox
+from regcode.tools.base import BaseTool, ToolParam, ToolResult
+
+
+class PythonCodeTool(BaseTool):
+    """Execute Python code in a Monty sandbox."""
+
+    name = "python_code"
+    description = (
+        "Execute Python code in an isolated Monty sandbox "
+        "environment with Rust-based security and resource limits."
+    )
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam("code", "string", "Python code to execute", required=True),
+            ToolParam(
+                "timeout",
+                "number",
+                "Execution timeout in seconds",
+                required=False,
+                default=10,
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        code = kwargs.get("code")
+        timeout = kwargs.get("timeout", 10)
+        if not code:
+            return ToolResult(
+                output="Missing required parameter: code",
+                error=True,
+            )
+        # Coerce timeout to float (LLM may send string like "15")
+        try:
+            timeout = float(timeout)
+        except (TypeError, ValueError):
+            timeout = 10.0
+        sandbox = MontySandbox()
+        try:
+            result = sandbox.run_python(code, timeout=timeout)
+            return ToolResult(
+                output=(
+                    f"stdout: {result.stdout}\n"
+                    f"stderr: {result.stderr}\n"
+                    f"exit_code: {result.exit_code}\n"
+                    f"time: {result.execution_time:.2f}s\n"
+                    f"result: {result.result}"
+                ),
+                error=not result.success,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                exit_code=result.exit_code,
+                result=result.result,
+            )
+        finally:
+            sandbox.cleanup()
+
+
+class ShellCommandTool(BaseTool):
+    """Execute shell commands with security restrictions.
+
+    Runs commands through a controlled allowlist to prevent arbitrary
+    command execution. Only safe, read-only commands are permitted.
+    """
+
+    name = "shell_command"
+    description = (
+        "Execute a shell command with security restrictions. "
+        "Only a controlled set of read-only commands are allowed "
+        "(ls, cat, echo, head, tail, wc, grep, sort, uniq, date, pwd, whoami, "
+        "id, uname, df, free, which, type). Commands are subject to timeout limits."
+    )
+
+    # Whitelist of safe, read-only shell commands
+    ALLOWED_COMMANDS = frozenset([
+        "ls", "cat", "echo", "head", "tail", "wc", "grep", "sort",
+        "uniq", "date", "pwd", "whoami", "id", "uname", "df",
+        "free", "which", "type", "stat", "file", "sha256sum",
+        "md5sum", "base64", "xxd", "od", "hexdump", "find",
+    ])
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "command",
+                "string",
+                "Shell command to execute (restricted to safe commands)",
+                required=True,
+            ),
+            ToolParam(
+                "timeout",
+                "number",
+                "Execution timeout in seconds",
+                required=False,
+                default=10,
+            ),
+        ]
+
+    @staticmethod
+    def _validate_command(command: str) -> tuple[bool, str]:
+        """Validate that the command is safe to execute.
+
+        Returns (is_valid, error_message).
+        """
+        if not command or not command.strip():
+            return False, "Empty command"
+
+        # Strip quotes and leading/trailing whitespace
+        cmd = command.strip()
+        cmd = cmd.strip("'\"")
+
+        # Block dangerous characters that could break out of the command.
+        # We allow quotes for multi-word arguments but validate their content.
+        # CRITICAL: Do NOT allow & | ; $ ` ( ) ! < > because they enable
+        # command chaining (&&, ||, |, &), substitution ($(..), `..`),
+        # redirection (>, <), and variable expansion ($VAR)
+        for c in cmd:
+            if c.isalnum() or c in ' .-_/+#,:\'"*':
+                continue
+            return False, (
+                "Command contains disallowed characters. "
+                "Only alphanumeric, spaces, and .-_/+#,:,'\"* are permitted."
+            )
+
+        # Extract the base command
+        parts = cmd.split()
+        if not parts:
+            return False, "No command specified"
+
+        base_cmd = parts[0]
+
+        # Check if the command is in the allowlist
+        # Handle paths like /bin/ls, /usr/bin/cat, etc.
+        if "/" in base_cmd:
+            base_cmd = base_cmd.rsplit("/", 1)[-1]
+
+        if base_cmd not in ShellCommandTool.ALLOWED_COMMANDS:
+            allowed_list = ", ".join(sorted(ShellCommandTool.ALLOWED_COMMANDS))
+            return False, (
+                f"Command '{base_cmd}' is not allowed. "
+                f"Only these commands are permitted: {allowed_list}"
+            )
+
+        # Validate arguments for dangerous patterns, even inside quotes
+        for part in parts[1:]:
+            # Strip quotes from argument for validation
+            clean = part.strip("'\"")
+
+            # Block path traversal in arguments
+            if ".." in clean:
+                return False, (
+                    "Path traversal ('..') is not allowed in command arguments"
+                )
+
+            # Block any dangerous characters that could be used for injection
+            # Block any dangerous characters that could be used for injection
+            # even inside quoted strings
+            if not all(
+                c.isalnum() or c in ' .-_/+#,:\'"*-'
+                for c in clean
+            ):
+                return False, (
+                    f"Disallowed characters detected in argument '{part}'"
+                )
+
+            # Block arguments that look like shell patterns for command
+            # substitution (contains $ or backtick)
+            if "$" in clean or "`" in clean:
+                return False, (
+                    "Shell substitution ($...) or backticks are not allowed"
+                )
+
+        return True, ""
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        command = kwargs.get("command")
+        timeout = kwargs.get("timeout", 10)
+        if not command:
+            return ToolResult(
+                output="Missing required parameter: command",
+                error=True,
+            )
+        # Coerce timeout to float (LLM may send string like "15")
+        try:
+            timeout = float(timeout)
+        except (TypeError, ValueError):
+            timeout = 10.0
+
+        # Validate command against allowlist
+        is_valid, error_msg = self._validate_command(command)
+        if not is_valid:
+            return ToolResult(
+                output=f"Command rejected: {error_msg}",
+                error=True,
+                exit_code=1,
+            )
+
+        start = time.time()
+        try:
+            result = subprocess.run(
+                command.split(),
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+            elapsed = time.time() - start
+            return ToolResult(
+                output=(
+                    f"stdout: {result.stdout}\n"
+                    f"stderr: {result.stderr}\n"
+                    f"exit_code: {result.returncode}\n"
+                    f"time: {elapsed:.2f}s"
+                ),
+                error=result.returncode != 0,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                exit_code=result.returncode,
+            )
+        except subprocess.TimeoutExpired as e:
+            elapsed = time.time() - start
+            return ToolResult(
+                output=(
+                    f"stdout: {e.stdout or ''}\n"
+                    f"stderr: {e.stderr or ''}\n"
+                    f"exit_code: -1\n"
+                    f"time: timeout after {timeout}s"
+                ),
+                error=True,
+                exit_code=-1,
+            )
+
+
+class ReadFileTool(BaseTool):
+    """Read files from the sandbox filesystem."""
+
+    name = "read_file"
+    description = "Read the contents of a file from the sandbox filesystem."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam("path", "string", "Path to the file to read", required=True),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        path = kwargs.get("path")
+        if not path:
+            return ToolResult(
+                output="Missing required parameter: path",
+                error=True,
+            )
+        # Read from host filesystem (same as browse_dir)
+        p = Path(path)
+        if not p.exists():
+            return ToolResult(
+                output=f"File not found: {path}",
+                error=True,
+                exit_code=1,
+            )
+        try:
+            content = p.read_text()
+            return ToolResult(output=f"File: {path}\n{content}", exit_code=0)
+        except Exception as e:
+            return ToolResult(
+                output=f"Error reading file: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+class FetchGitDiffTool(BaseTool):
+    """Fetch the git diff of the current repository."""
+
+    name = "fetch_git_diff"
+    description = "Fetch the git diff of the current repository."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return []
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        try:
+            result = subprocess.run(
+                ["git", "diff"],
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode != 0:
+                return ToolResult(
+                    output=f"Error fetching git diff: {result.stderr}",
+                    error=True,
+                    exit_code=result.returncode,
+                )
+            return ToolResult(output=result.stdout, exit_code=0)
+        except subprocess.TimeoutExpired:
+            return ToolResult(
+                output="SANDBOX_ERROR: Git diff command timed out",
+                error=True,
+                exit_code=-1,
+            )
+
+class WriteFileTool(BaseTool):
+    """Write files to the host filesystem."""
+
+    name = "write_file"
+    description = "Write content to a file on the host filesystem."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam("path", "string", "Path to write to", required=True),
+            ToolParam("content", "string", "Content to write", required=True),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        path = kwargs.get("path")
+        content = kwargs.get("content")
+        if not path:
+            return ToolResult(
+                output="Missing required parameter: path",
+                error=True,
+            )
+        if not content:
+            return ToolResult(
+                output="Missing required parameter: content",
+                error=True,
+            )
+        p = Path(path)
+        # Block path traversal
+        if ".." in p.parts:
+            return ToolResult(
+                output="Error writing file: Path traversal ('..') is not allowed",
+                error=True,
+                exit_code=1,
+            )
+        # Resolve the path to get absolute path
+        resolved = p.resolve()
+        try:
+            resolved.parent.mkdir(parents=True, exist_ok=True)
+            resolved.write_text(content)
+            return ToolResult(
+                output=f"Written {len(content)} bytes to {path}",
+                exit_code=0,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Error writing file: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class PatchFileTool(BaseTool):
+    """Replace a range of lines in an existing file."""
+
+    name = "patch_file"
+    description = (
+        "Replace lines start_line through end_line (inclusive, 1-indexed) in a file "
+        "with new content. The file must already exist."
+    )
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam("path", "string", "Path to the file", required=True),
+            ToolParam(
+                "start_line",
+                "integer",
+                "Starting line number (1-indexed, inclusive)",
+                required=True,
+            ),
+            ToolParam(
+                "end_line",
+                "integer",
+                "Ending line number (1-indexed, inclusive)",
+                required=True,
+            ),
+            ToolParam(
+                "replacement",
+                "string",
+                "Text to replace the specified line range with",
+                required=True,
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        path = kwargs.get("path")
+        start_line = kwargs.get("start_line")
+        end_line = kwargs.get("end_line")
+        replacement = kwargs.get("replacement")
+
+        if not path:
+            return ToolResult(
+                output="Missing required parameter: path",
+                error=True,
+            )
+        if start_line is None:
+            return ToolResult(
+                output="Missing required parameter: start_line",
+                error=True,
+            )
+        if end_line is None:
+            return ToolResult(
+                output="Missing required parameter: end_line",
+                error=True,
+            )
+        if replacement is None:
+            return ToolResult(
+                output="Missing required parameter: replacement",
+                error=True,
+            )
+
+        # Coerce line numbers
+        try:
+            start_line = int(start_line)
+            end_line = int(end_line)
+        except (TypeError, ValueError):
+            return ToolResult(
+                output="Error: start_line and end_line must be integers",
+                error=True,
+                exit_code=1,
+            )
+
+        if start_line > end_line:
+            return ToolResult(
+                output="Error: start_line must be <= end_line",
+                error=True,
+                exit_code=1,
+            )
+
+        p = Path(path)
+        if ".." in p.parts:
+            return ToolResult(
+                output="Error: Path traversal ('..') is not allowed",
+                error=True,
+                exit_code=1,
+            )
+
+        resolved = p.resolve()
+        if not resolved.exists():
+            return ToolResult(
+                output=f"File not found: {path}",
+                error=True,
+                exit_code=1,
+            )
+
+        try:
+            raw_content = resolved.read_text()
+            trailing_newline = raw_content.endswith("\n") if raw_content else False
+            lines = raw_content.splitlines()
+            total = len(lines)
+
+            if start_line < 1 or end_line > total:
+                return ToolResult(
+                    output=(
+                        f"Line range {start_line}-{end_line} out of bounds "
+                        f"for file with {total} lines"
+                    ),
+                    error=True,
+                    exit_code=1,
+                )
+
+            # Build new content: before range + replacement + after range
+            prefix = "\n".join(lines[: start_line - 1])
+            suffix = "\n".join(lines[end_line:])
+
+            if replacement:
+                if prefix and suffix:
+                    new_content = f"{prefix}\n{replacement}\n{suffix}"
+                elif prefix:
+                    new_content = f"{prefix}\n{replacement}"
+                elif suffix:
+                    new_content = f"{replacement}\n{suffix}"
+                else:
+                    new_content = replacement
+            else:
+                # Empty replacement: just join prefix and suffix
+                if prefix and suffix:
+                    new_content = f"{prefix}\n{suffix}"
+                elif prefix:
+                    new_content = prefix
+                elif suffix:
+                    new_content = suffix
+                else:
+                    new_content = ""
+
+            if trailing_newline:
+                new_content += "\n"
+
+            resolved.write_text(new_content)
+            return ToolResult(
+                output=(
+                    f"Replaced lines {start_line}-{end_line} in {path}\n"
+                    f"New content: {replacement}"
+                ),
+                exit_code=0,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Error patching file: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class ListDirTool(BaseTool):
+    """List directory contents from the sandbox filesystem."""
+
+    name = "list_dir"
+    description = "List contents of a directory in the sandbox filesystem."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "path",
+                "string",
+                "Directory path to list",
+                required=False,
+                default=".",
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        path = kwargs.get("path", ".")
+        # List from host filesystem
+        p = Path(path)
+        if not p.exists():
+            return ToolResult(
+                output=f"Directory not found: {path}",
+                error=True,
+                exit_code=1,
+            )
+        if not p.is_dir():
+            return ToolResult(
+                output=f"Not a directory: {path}",
+                error=True,
+                exit_code=1,
+            )
+        try:
+            entries = sorted(p.iterdir())
+            lines = [f"{e.name}/" if e.is_dir() else e.name for e in entries]
+            output_lines = "\n".join(lines)
+            if lines:
+                output = f"Directory: {path}\n{output_lines}"
+            else:
+                output = f"Directory: {path}\n(empty)"
+            return ToolResult(output=output, exit_code=0)
+        except Exception as e:
+            return ToolResult(
+                output=f"Error listing directory: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class SearchFilesTool(BaseTool):
+    """Search for files by name pattern."""
+
+    name = "search_files"
+    description = "Search for files matching a pattern in the sandbox filesystem."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "pattern",
+                "string",
+                "File name pattern to search for",
+                required=True,
+            ),
+            ToolParam(
+                "path",
+                "string",
+                "Directory to search in",
+                required=False,
+                default=".",
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        pattern = kwargs.get("pattern")
+        path = kwargs.get("path", ".")
+        if not pattern:
+            return ToolResult(
+                output="Missing required parameter: pattern",
+                error=True,
+            )
+        # Search on host filesystem
+        p = Path(path)
+        if not p.exists():
+            return ToolResult(
+                output=f"Directory not found: {path}",
+                error=True,
+                exit_code=1,
+            )
+        try:
+            matches = list(p.rglob(pattern))
+            results = (
+                "\n".join(
+                    str(m.relative_to(p)) for m in matches
+                )
+                if matches
+                else "(no matches)"
+            )
+            return ToolResult(
+                output=f"Pattern: {pattern}\nPath: {path}\n{results}",
+                exit_code=0,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Error searching files: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class BrowseDirTool(BaseTool):
+    """Browse a directory tree and list all files."""
+
+    name = "browse_dir"
+    description = (
+        "Recursively list all files and directories starting from a path. "
+        "Shows the full directory tree structure. Useful for understanding "
+        "the layout of a codebase before reading specific files."
+    )
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "path",
+                "string",
+                "Directory path to browse",
+                required=False,
+                default=".",
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        path = kwargs.get("path", ".")
+        try:
+            p = Path(path)
+            if not p.exists():
+                return ToolResult(
+                    output=f"Path not found: {path}",
+                    error=True,
+                    exit_code=1,
+                )
+
+            lines = []
+            for root, dirs, files in os.walk(p):
+                # Skip hidden dirs and common noise
+                dirs[:] = [d for d in dirs if not d.startswith('.')
+                           and d not in {'__pycache__', '.git', '.venv',
+                                         'node_modules', 'dist', 'build'}]
+                rel = os.path.relpath(root, p)
+                indent = "  " if rel == "." else "  " * (rel.count(os.sep) + 1)
+                lines.append(f"{indent}{os.path.basename(root)}/")
+                for f in sorted(files):
+                    lines.append(f"{indent}  {f}")
+
+            return ToolResult(
+                output=f"Directory: {path}\n" + "\n".join(lines)
+                       if lines else f"Directory: {path}\n(empty)",
+                exit_code=0,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Error browsing directory: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class SearchDirTool(BaseTool):
+    """Search file contents within a directory tree."""
+
+    name = "search_dir"
+    description = (
+        "Search for a pattern inside all files within a directory tree. "
+        "Returns matching file paths and line snippets. Useful for finding "
+        "specific code patterns, imports, or references across a codebase."
+    )
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "pattern",
+                "string",
+                "Text pattern to search for",
+                required=True,
+            ),
+            ToolParam(
+                "path",
+                "string",
+                "Directory to search in",
+                required=False,
+                default=".",
+            ),
+            ToolParam(
+                "file_type",
+                "string",
+                "File extension to filter (e.g. .py, .js). Empty for all files.",
+                required=False,
+                default="",
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        pattern = kwargs.get("pattern")
+        path = kwargs.get("path", ".")
+        file_type = kwargs.get("file_type", "")
+        if not pattern:
+            return ToolResult(
+                output="Missing required parameter: pattern",
+                error=True,
+            )
+        try:
+            p = Path(path)
+            if not p.exists():
+                return ToolResult(
+                    output=f"Directory not found: {path}",
+                    error=True,
+                    exit_code=1,
+                )
+
+            matches = []
+            for root, dirs, files in os.walk(p):
+                # Skip hidden dirs and common noise
+                dirs[:] = [d for d in dirs if not d.startswith('.')
+                           and d not in {'__pycache__', '.git', '.venv',
+                                         'node_modules', 'dist', 'build'}]
+                for f in sorted(files):
+                    if file_type and not f.endswith(file_type):
+                        continue
+                    fp = Path(root) / f
+                    try:
+                        content = fp.read_text(errors='ignore')
+                        for line_no, line in enumerate(content.split('\n'), 1):
+                            if pattern in line:
+                                matches.append(
+                                    f"{fp}:{line_no}: {line.strip()}"
+                                )
+                    except Exception:
+                        continue
+
+            if not matches:
+                return ToolResult(
+                    output=(
+                        f"Search: '{pattern}' in {path} "
+                        f"(file_type: {file_type or 'all'})\n(no matches)"
+                    ),
+                    exit_code=0,
+                )
+
+            return ToolResult(
+                output=(
+                    f"Search: '{pattern}' in {path} "
+                    f"(file_type: {file_type or 'all'})\n" +
+                    "\n".join(matches[:100]) +
+                    (f"\n... ({len(matches) - 100} more matches)"
+                     if len(matches) > 100 else "")
+                ),
+                exit_code=0,
+            )
+        except Exception as e:
+            return ToolResult(
+                output=f"Error searching directory: {str(e)}",
+                error=True,
+                exit_code=1,
+            )
+
+
+class RunPythonScriptTool(BaseTool):
+    """Run a Python script from a file."""
+
+    name = "run_script"
+    description = "Execute a Python script file in the Monty sandbox."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return [
+            ToolParam(
+                "script_path",
+                "string",
+                "Path to the Python script file",
+                required=True,
+            ),
+            ToolParam(
+                "args",
+                "string",
+                "Command-line arguments for the script",
+                required=False,
+                default="",
+            ),
+            ToolParam(
+                "timeout",
+                "number",
+                "Execution timeout in seconds",
+                required=False,
+                default=10,
+            ),
+        ]
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        script_path = kwargs.get("script_path")
+        args = kwargs.get("args", "")
+        timeout = kwargs.get("timeout", 10)
+        if not script_path:
+            return ToolResult(
+                output="Missing required parameter: script_path",
+                error=True,
+            )
+        sandbox = MontySandbox()
+        try:
+            script_full = sandbox.sandbox_root / script_path
+            if not script_full.exists():
+                return ToolResult(
+                    output=f"Script not found: {script_path}",
+                    error=True,
+                    exit_code=1,
+                )
+            import subprocess
+
+            cmd = ["python3", str(script_full)]
+            if args:
+                cmd.extend(args.split())
+
+            result = subprocess.run(
+                cmd,
+                cwd=str(sandbox.sandbox_root),
+                capture_output=True,
+                text=True,
+                timeout=timeout,
+            )
+
+            return ToolResult(
+                output=(
+                    f"stdout: {result.stdout}\n"
+                    f"stderr: {result.stderr}\n"
+                    f"exit_code: {result.returncode}"
+                ),
+                error=result.returncode != 0,
+                stdout=result.stdout,
+                stderr=result.stderr,
+                exit_code=result.returncode,
+            )
+        except subprocess.TimeoutExpired:
+            return ToolResult(
+                output="SANDBOX_ERROR: Execution timed out",
+                error=True,
+                exit_code=-1,
+            )
+        finally:
+            sandbox.cleanup()
+
+
+class SystemInfoTool(BaseTool):
+    """Get system information."""
+
+    name = "system_info"
+    description = "Get system information (OS, Python version, available resources)."
+
+    @property
+    def params(self) -> list[ToolParam]:
+        return []
+
+    def execute(self, **kwargs: Any) -> ToolResult:
+        import platform
+        import sys
+
+        try:
+            python_version = sys.version
+            os_name = platform.system()
+            os_release = platform.release()
+            architecture = platform.machine()
+            cpu_count = os.cpu_count() or 1
+
+            # Get memory info
+            mem_total = 0
+            try:
+                import psutil
+
+                mem = psutil.virtual_memory()
+                mem_total = mem.total / (1024**3)  # GB
+            except ImportError:
+                try:
+                    mem_total = _get_mem_from_proc()
+                except Exception:
+                    mem_total = "unknown"
+
+            info = f"OS: {os_name} {os_release}\n"
+            info += f"Architecture: {architecture}\n"
+            info += f"Python: {python_version}\n"
+            info += f"CPU cores: {cpu_count}\n"
+            info += f"Total memory: {mem_total} GB"
+
+            return ToolResult(output=info, exit_code=0)
+        except Exception as e:
+            return ToolResult(output=f"Error: {str(e)}", error=True, exit_code=1)
+
+
+def _get_mem_from_proc() -> float:
+    """Get total memory from /proc/meminfo on Linux."""
+    with open("/proc/meminfo") as f:
+        for line in f:
+            if line.startswith("MemTotal:"):
+                kb = int(line.split()[1])
+                return kb / (1024**2)  # Convert KB to GB
+    return 0
+
+
+def create_default_tools() -> list[BaseTool]:
+    """Create the default set of tools for the agent."""
+    return [
+        PythonCodeTool(),
+        ShellCommandTool(),
+        ReadFileTool(),
+        WriteFileTool(),
+        PatchFileTool(),
+        ListDirTool(),
+        SearchFilesTool(),
+        BrowseDirTool(),
+        SearchDirTool(),
+        RunPythonScriptTool(),
+        SystemInfoTool(),
+        FetchGitDiffTool(),
+    ]