vibecore 0.2.0a1__py3-none-any.whl

vibecore/tools/python/helpers.py

@@ -0,0 +1,80 @@
+"""Helper functions for Python execution tool."""
+
+import tempfile
+from io import BytesIO
+
+from agents import RunContextWrapper
+
+from vibecore.context import VibecoreContext
+
+try:
+    from PIL import Image  # type: ignore[import-not-found]
+    from term_image.image import AutoImage  # type: ignore[import-not-found]
+
+    TERM_IMAGE_AVAILABLE = True
+except ImportError:
+    TERM_IMAGE_AVAILABLE = False
+
+
+async def execute_python_helper(ctx: RunContextWrapper[VibecoreContext], code: str) -> str:
+    """Helper function to execute Python code.
+
+    This is the actual implementation extracted from the tool decorator.
+    """
+    result = await ctx.context.python_manager.execute(code)
+
+    # Format the response
+    response_parts = []
+
+    if result.output:
+        response_parts.append(f"Output:\n```\n{result.output}```")
+
+    if result.error:
+        response_parts.append(f"Error:\n```\n{result.error}```")
+
+    if result.value is not None and not result.output:
+        # Only show the value if there was no print output
+        response_parts.append(f"Result: `{result.value}`")
+
+    # Display any captured matplotlib images
+    if result.images:
+        for i, image_data in enumerate(result.images):
+            try:
+                # Save image to temporary file
+                with tempfile.NamedTemporaryFile(mode="wb", suffix=".png", delete=False) as tmp_file:
+                    tmp_file.write(image_data)
+                    temp_path = tmp_file.name
+
+                # Add Markdown image reference to response
+                response_parts.append(f"\n![Plot {i + 1}](file://{temp_path})")
+
+                # Display in terminal if term-image is available
+                if TERM_IMAGE_AVAILABLE:
+                    # Load image from bytes for terminal display
+                    buf = BytesIO(image_data)
+                    pil_image = Image.open(buf)  # type: ignore
+
+                    # Use AutoImage for automatic terminal detection
+                    term_image = AutoImage(pil_image, width=80)  # type: ignore
+
+                    # Display the image
+                    term_image.draw(h_align="center", v_align="top", pad_width=1, pad_height=1)  # type: ignore
+
+                    # Close the image
+                    pil_image.close()
+                    buf.close()
+
+                    # Note that an image was displayed
+                    if i == 0:
+                        response_parts.append("[Image displayed in terminal]")
+                else:
+                    # Note that term-image is not available
+                    if i == 0:
+                        response_parts.append("[Matplotlib plots saved to temporary files]")
+            except Exception as e:
+                response_parts.append(f"\n[Error processing image {i + 1}: {e}]")
+
+    if not response_parts:
+        return "Code executed successfully (no output)."
+
+    return "\n\n".join(response_parts)

vibecore/tools/python/manager.py

@@ -0,0 +1,208 @@
+"""Python code execution manager."""
+
+import ast
+import sys
+import warnings
+from dataclasses import dataclass
+from io import StringIO
+from typing import Any
+
+
+@dataclass
+class ExecutionResult:
+    """Result of Python code execution."""
+
+    success: bool
+    output: str
+    error: str
+    value: Any = None
+    images: list[bytes] | None = None  # Store captured matplotlib images
+
+
+class TerminalImageCapture(StringIO):
+    """Custom StringIO that captures term-image output."""
+
+    def __init__(self):
+        super().__init__()
+        self.has_term_image_output = False
+
+    def write(self, s: str) -> int:
+        # Check if this is term-image output (usually contains escape sequences)
+        if "\033[" in s or "\x1b[" in s:
+            self.has_term_image_output = True
+        return super().write(s)
+
+
+class PythonExecutionManager:
+    """Manages Python code execution with persistent context."""
+
+    def __init__(self) -> None:
+        """Initialize the execution manager with empty context."""
+        self.globals: dict[str, Any] = {"__builtins__": __builtins__}
+        self.locals: dict[str, Any] = {}
+        self._setup_matplotlib_backend()
+
+    def _setup_matplotlib_backend(self) -> None:
+        """Set up the terminal matplotlib backend."""
+        # Pre-configure matplotlib to use our custom backend
+        # This will take effect when matplotlib is imported
+        # import os
+
+        # # Set the backend environment variable
+        # os.environ["MPLBACKEND"] = "module://vibecore.tools.python.backends.terminal_backend"
+
+        # # Also set it in the execution globals
+        # self.globals["__matplotlib_backend__"] = "module://vibecore.tools.python.backends.terminal_backend"
+
+        # Add a helper function to set matplotlib backend programmatically
+        backend_setup_code = """
+def _setup_matplotlib_terminal():
+    '''Helper to ensure matplotlib uses terminal backend.'''
+    try:
+        import matplotlib
+        matplotlib.use('module://vibecore.tools.python.backends.terminal_backend')
+    except ImportError:
+        pass
+_setup_matplotlib_terminal()
+"""
+        exec(backend_setup_code, self.globals, self.globals)
+
+    async def execute(self, code: str) -> ExecutionResult:
+        """Execute Python code and return the result.
+
+        Args:
+            code: Python code to execute.
+
+        Returns:
+            ExecutionResult with success status, output, errors, and return value.
+        """
+        # Capture stdout and stderr
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        stdout_capture = TerminalImageCapture()
+        stderr_capture = StringIO()
+
+        # Capture warnings
+        old_showwarning = warnings.showwarning
+
+        def custom_showwarning(message, category, filename, lineno, file=None, line=None):
+            stderr_capture.write(warnings.formatwarning(message, category, filename, lineno, line))
+
+        try:
+            sys.stdout = stdout_capture
+            sys.stderr = stderr_capture
+            warnings.showwarning = custom_showwarning
+
+            # Parse the code to handle async functions
+            tree = ast.parse(code, mode="exec")
+
+            # Check if we need to run in async context
+            has_await = self._has_await_at_module_level(tree)
+
+            if has_await:
+                # Create an event loop if needed and run async code
+                result_value = await self._execute_async(code)
+            else:
+                # Normal execution
+                result_value = None
+
+                # Check if last statement is an expression we should evaluate
+                last_is_expr = tree.body and isinstance(tree.body[-1], ast.Expr)
+
+                if last_is_expr:
+                    # Execute all but the last statement
+                    if len(tree.body) > 1:
+                        exec(
+                            compile(ast.Module(body=tree.body[:-1], type_ignores=[]), "<string>", "exec"),
+                            self.globals,
+                            self.globals,
+                        )
+                    # Evaluate the last expression
+                    last_expr = tree.body[-1]
+                    assert isinstance(last_expr, ast.Expr)  # We already checked this
+                    result_value = eval(
+                        compile(ast.Expression(body=last_expr.value), "<string>", "eval"),
+                        self.globals,
+                        self.globals,
+                    )
+                else:
+                    # Execute everything normally
+                    exec(code, self.globals, self.globals)
+
+            # Check for captured matplotlib images
+            images = None
+            try:
+                # Import the backend module to access captured images
+                from vibecore.tools.python.backends import terminal_backend
+
+                captured_images = terminal_backend.get_captured_images()
+                if captured_images:
+                    images = captured_images
+                    terminal_backend.clear_captured_images()
+            except Exception:
+                # If we can't get images, just continue without them
+                pass
+
+            return ExecutionResult(
+                success=True,
+                output=stdout_capture.getvalue(),
+                error=stderr_capture.getvalue(),
+                value=result_value,
+                images=images,
+            )
+
+        except SyntaxError as e:
+            return ExecutionResult(
+                success=False,
+                output="",
+                error=f"SyntaxError: {e}",
+                value=None,
+            )
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                output=stdout_capture.getvalue(),
+                error=f"{type(e).__name__}: {e}",
+                value=None,
+            )
+        finally:
+            # Restore stdout, stderr, and warnings
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            warnings.showwarning = old_showwarning
+
+    def _has_await_at_module_level(self, tree: ast.Module) -> bool:
+        """Check if there are await expressions at module level."""
+        for node in tree.body:
+            if isinstance(node, ast.Expr) and isinstance(node.value, ast.Await):
+                return True
+            # Check for await in direct assignments
+            if isinstance(node, ast.Assign) and isinstance(node.value, ast.Await):
+                return True
+        return False
+
+    async def _execute_async(self, code: str) -> Any:
+        """Execute code containing await expressions."""
+        # Wrap the entire code in an async function
+        lines = code.splitlines()
+        indented_code = "\n".join(f"    {line}" if line.strip() else "" for line in lines)
+        wrapped_code = f"async def __async_exec():\n{indented_code}\n    return None"
+
+        # Define the async function
+        exec(wrapped_code, self.globals, self.globals)
+
+        # Run it
+        result = await self.globals["__async_exec"]()
+
+        # Clean up
+        del self.globals["__async_exec"]
+
+        return result
+
+    def reset_context(self) -> None:
+        """Reset the execution context."""
+        matplotlib_backend = self.globals.get("__matplotlib_backend__")
+        self.globals = {"__builtins__": __builtins__}
+        if matplotlib_backend is not None:
+            self.globals["__matplotlib_backend__"] = matplotlib_backend
+        self.locals = {}

vibecore/tools/python/tools.py

@@ -0,0 +1,27 @@
+"""Python code execution tool."""
+
+from agents import RunContextWrapper, function_tool
+
+from vibecore.context import VibecoreContext
+
+from .helpers import execute_python_helper
+
+
+@function_tool
+async def execute_python(ctx: RunContextWrapper[VibecoreContext], code: str) -> str:
+    """Execute Python code with persistent context across the session.
+
+    The execution environment maintains state between calls, allowing you to:
+    - Define variables and functions that persist
+    - Import modules that remain available
+    - Build up complex computations step by step
+    - Make sure to define code as function so that we can use it later
+
+    Args:
+        ctx: The run context wrapper containing the Python execution manager.
+        code: Python code to execute.
+
+    Returns:
+        A string containing the execution result, output, or error message.
+    """
+    return await execute_python_helper(ctx, code)

vibecore/tools/shell/__init__.py

@@ -0,0 +1,5 @@
+"""Shell and system tools for Vibecore agents."""
+
+from .tools import bash, glob, grep, ls
+
+__all__ = ["bash", "glob", "grep", "ls"]

vibecore/tools/shell/executor.py

@@ -0,0 +1,223 @@
+"""Shell command execution logic."""
+
+import asyncio
+import glob as glob_module
+import re
+import subprocess
+from pathlib import Path
+
+from vibecore.tools.file.utils import PathValidationError, validate_file_path
+
+
+async def bash_executor(command: str, timeout: int | None = None) -> tuple[str, int]:
+    """Execute a bash command asynchronously.
+
+    Args:
+        command: The bash command to execute
+        timeout: Optional timeout in milliseconds (max 600000)
+
+    Returns:
+        Tuple of (output, exit_code)
+    """
+    # Set default timeout if not provided
+    if timeout is None:
+        timeout = 120000  # 2 minutes default
+
+    # Validate timeout
+    if timeout < 0:
+        return "Error: Timeout must be positive", 1
+    if timeout > 600000:
+        return "Error: Timeout cannot exceed 600000ms (10 minutes)", 1
+
+    # Convert timeout to seconds
+    timeout_seconds = timeout / 1000.0
+
+    process = None
+    try:
+        # Create subprocess
+        process = await asyncio.create_subprocess_shell(
+            command,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            shell=True,
+            executable="/bin/bash",
+        )
+
+        # Wait for completion with timeout
+        stdout, _ = await asyncio.wait_for(process.communicate(), timeout=timeout_seconds)
+
+        # Decode output
+        output = stdout.decode("utf-8", errors="replace")
+
+        # Truncate if too long
+        if len(output) > 30000:
+            output = output[:30000] + "\n... (output truncated)"
+
+        return output, process.returncode or 0
+
+    except TimeoutError:
+        # Kill the process if it times out
+        if process and process.returncode is None:
+            process.kill()
+            await process.wait()
+        return f"Error: Command timed out after {timeout}ms", 124
+
+    except Exception as e:
+        return f"Error executing command: {e}", 1
+
+
+async def glob_files(pattern: str, path: str | None = None) -> list[str]:
+    """Find files matching a glob pattern.
+
+    Args:
+        pattern: The glob pattern to match
+        path: Optional directory to search in (defaults to CWD)
+
+    Returns:
+        List of matching file paths sorted by modification time
+    """
+    try:
+        # Validate and resolve the path
+        search_path = Path.cwd() if path is None else validate_file_path(path)
+
+        # Validate path is a directory
+        if not search_path.is_dir():
+            return [f"Error: Path is not a directory: {search_path}"]
+    except PathValidationError as e:
+        return [f"Error: {e}"]
+
+    try:
+        # Convert to absolute path
+        search_path = search_path.resolve()
+
+        # Perform glob search
+        full_pattern = str(search_path / pattern)
+        matches = list(glob_module.glob(full_pattern, recursive=True))
+
+        # Filter to only files (not directories)
+        file_matches = [m for m in matches if Path(m).is_file()]
+
+        # Sort by modification time (newest first)
+        file_matches.sort(key=lambda x: Path(x).stat().st_mtime, reverse=True)
+
+        # Return relative paths if searching in CWD, absolute otherwise
+        if path is None:
+            file_matches = [str(Path(m).relative_to(Path.cwd())) for m in file_matches]
+
+        return file_matches
+
+    except Exception as e:
+        return [f"Error: {e}"]
+
+
+async def grep_files(pattern: str, path: str | None = None, include: str | None = None) -> list[str]:
+    """Search file contents using regular expressions.
+
+    Args:
+        pattern: The regex pattern to search for
+        path: Directory to search in (defaults to CWD)
+        include: File pattern to include (e.g. "*.js")
+
+    Returns:
+        List of file paths containing matches, sorted by modification time
+    """
+    try:
+        # Validate and resolve the path
+        search_path = Path.cwd() if path is None else validate_file_path(path)
+
+        # Validate path is a directory
+        if not search_path.is_dir():
+            return [f"Error: Path is not a directory: {search_path}"]
+    except PathValidationError as e:
+        return [f"Error: {e}"]
+
+    try:
+        # Compile regex pattern
+        regex = re.compile(pattern)
+    except re.error as e:
+        return [f"Error: Invalid regex pattern: {e}"]
+
+    try:
+        # Get all files to search
+        if include:
+            # Use glob to find files matching the include pattern
+            search_pattern = "**/" + include
+            all_files = list(search_path.glob(search_pattern))
+        else:
+            # Search all files recursively
+            all_files = [f for f in search_path.rglob("*") if f.is_file()]
+
+        # Search for pattern in each file
+        matching_files = []
+        for file_path in all_files:
+            try:
+                # Skip binary files
+                with file_path.open("r", encoding="utf-8", errors="replace") as f:
+                    content = f.read()
+                    if regex.search(content):
+                        matching_files.append(file_path)
+            except Exception:
+                # Skip files that can't be read
+                continue
+
+        # Sort by modification time (newest first)
+        matching_files.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+
+        # Return relative paths if searching in CWD, absolute otherwise
+        if path is None:
+            result = [str(f.relative_to(Path.cwd())) for f in matching_files]
+        else:
+            result = [str(f) for f in matching_files]
+
+        return result
+
+    except Exception as e:
+        return [f"Error: {e}"]
+
+
+async def list_directory(path: str, ignore: list[str] | None = None) -> list[str]:
+    """List files and directories in a given path.
+
+    Args:
+        path: The absolute path to list
+        ignore: Optional list of glob patterns to ignore
+
+    Returns:
+        List of entries in the directory
+    """
+    try:
+        # Validate and resolve the path
+        dir_path = validate_file_path(path)
+
+        # Validate path is a directory
+        if not dir_path.is_dir():
+            return [f"Error: Path is not a directory: {dir_path}"]
+    except PathValidationError as e:
+        return [f"Error: {e}"]
+
+    try:
+        # Get all entries
+        entries = []
+        for entry in sorted(dir_path.iterdir()):
+            # Skip if matches ignore pattern
+            if ignore:
+                skip = False
+                for pattern in ignore:
+                    if entry.match(pattern):
+                        skip = True
+                        break
+                if skip:
+                    continue
+
+            # Format entry
+            if entry.is_dir():
+                entries.append(f"{entry.name}/")
+            else:
+                entries.append(entry.name)
+
+        return entries
+
+    except PermissionError:
+        return [f"Error: Permission denied accessing directory: {path}"]
+    except Exception as e:
+        return [f"Error: {e}"]