superqode 0.1.5__py3-none-any.whl

superqode/providers/openresponses/tools/apply_patch.py

@@ -0,0 +1,352 @@
+"""
+Apply Patch Tool for Open Responses.
+
+Implements the apply_patch built-in tool for applying unified diff patches
+to files in the workspace. Critical for QIR (Quality Issue Resolution) fixes.
+
+Features:
+- Dry-run mode by default for safety
+- Git-based patch application
+- Validation before application
+- Detailed error reporting
+
+Usage:
+    tool = ApplyPatchTool(workspace_root="/path/to/project")
+
+    # Validate without applying
+    result = await tool.execute(patch_content, dry_run=True)
+
+    # Apply the patch
+    result = await tool.execute(patch_content, dry_run=False)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class PatchResult:
+    """Result of a patch operation."""
+
+    success: bool
+    message: str
+    files_modified: List[str] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+    dry_run: bool = True
+
+
+@dataclass
+class PatchOperation:
+    """A single file operation from a patch."""
+
+    operation: str  # "create", "update", "delete"
+    path: str
+    old_path: Optional[str] = None  # For renames
+
+
+class ApplyPatchTool:
+    """
+    Apply patch tool for Open Responses.
+
+    Applies unified diff patches to files in the workspace.
+    Uses git apply for robust patch handling.
+
+    Args:
+        workspace_root: Root directory for file operations
+        dry_run: If True (default), validate without applying
+        allow_outside_workspace: If True, allow patches to files outside workspace
+    """
+
+    def __init__(
+        self,
+        workspace_root: str,
+        dry_run: bool = True,
+        allow_outside_workspace: bool = False,
+    ):
+        self.workspace_root = Path(workspace_root).resolve()
+        self.dry_run = dry_run
+        self.allow_outside_workspace = allow_outside_workspace
+
+    async def execute(
+        self,
+        patch: str,
+        dry_run: Optional[bool] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute the patch operation.
+
+        Args:
+            patch: The patch content in unified diff format
+            dry_run: Override the default dry_run setting
+
+        Returns:
+            Dict with success status, message, and details
+        """
+        use_dry_run = dry_run if dry_run is not None else self.dry_run
+
+        # Parse patch to extract operations
+        operations = self._parse_patch(patch)
+
+        if not operations:
+            return {
+                "success": False,
+                "message": "No valid patch operations found",
+                "dry_run": use_dry_run,
+            }
+
+        # Validate paths
+        validation_errors = self._validate_paths(operations)
+        if validation_errors:
+            return {
+                "success": False,
+                "message": "Path validation failed",
+                "errors": validation_errors,
+                "dry_run": use_dry_run,
+            }
+
+        # Apply or validate the patch
+        if use_dry_run:
+            result = await self._validate_patch(patch)
+        else:
+            result = await self._apply_patch(patch)
+
+        return {
+            "success": result.success,
+            "message": result.message,
+            "files_modified": result.files_modified,
+            "errors": result.errors,
+            "dry_run": use_dry_run,
+        }
+
+    def _parse_patch(self, patch: str) -> List[PatchOperation]:
+        """Parse a patch to extract file operations."""
+        operations = []
+        lines = patch.split("\n")
+        current_file = None
+        is_new_file = False
+        is_delete = False
+
+        for line in lines:
+            if line.startswith("diff --git"):
+                # New file in patch
+                parts = line.split()
+                if len(parts) >= 4:
+                    # Extract paths: diff --git a/path b/path
+                    a_path = parts[2][2:] if parts[2].startswith("a/") else parts[2]
+                    b_path = parts[3][2:] if parts[3].startswith("b/") else parts[3]
+                    current_file = b_path if b_path != "/dev/null" else a_path
+                    is_new_file = False
+                    is_delete = False
+
+            elif line.startswith("new file mode"):
+                is_new_file = True
+
+            elif line.startswith("deleted file mode"):
+                is_delete = True
+
+            elif line.startswith("--- ") and current_file:
+                old_path = line[4:].strip()
+                if old_path.startswith("a/"):
+                    old_path = old_path[2:]
+                elif old_path == "/dev/null":
+                    is_new_file = True
+
+            elif line.startswith("+++ ") and current_file:
+                new_path = line[4:].strip()
+                if new_path.startswith("b/"):
+                    new_path = new_path[2:]
+                elif new_path == "/dev/null":
+                    is_delete = True
+
+                # Determine operation type
+                if is_delete:
+                    op_type = "delete"
+                elif is_new_file:
+                    op_type = "create"
+                else:
+                    op_type = "update"
+
+                operations.append(
+                    PatchOperation(
+                        operation=op_type,
+                        path=current_file,
+                    )
+                )
+                current_file = None
+
+        return operations
+
+    def _validate_paths(self, operations: List[PatchOperation]) -> List[str]:
+        """Validate that all paths are within the workspace."""
+        errors = []
+
+        if self.allow_outside_workspace:
+            return errors
+
+        for op in operations:
+            try:
+                full_path = (self.workspace_root / op.path).resolve()
+                if not str(full_path).startswith(str(self.workspace_root)):
+                    errors.append(f"Path '{op.path}' is outside workspace")
+            except Exception as e:
+                errors.append(f"Invalid path '{op.path}': {e}")
+
+        return errors
+
+    async def _validate_patch(self, patch: str) -> PatchResult:
+        """Validate a patch without applying it."""
+        # Write patch to temporary file
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".patch",
+            delete=False,
+        ) as f:
+            f.write(patch)
+            patch_file = f.name
+
+        try:
+            # Run git apply --check
+            proc = await asyncio.create_subprocess_exec(
+                "git",
+                "apply",
+                "--check",
+                patch_file,
+                cwd=str(self.workspace_root),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+
+            if proc.returncode == 0:
+                # Parse operations for file list
+                operations = self._parse_patch(patch)
+                return PatchResult(
+                    success=True,
+                    message="Patch validation successful",
+                    files_modified=[op.path for op in operations],
+                    dry_run=True,
+                )
+            else:
+                error_msg = stderr.decode("utf-8").strip()
+                return PatchResult(
+                    success=False,
+                    message="Patch validation failed",
+                    errors=[error_msg] if error_msg else ["Patch does not apply cleanly"],
+                    dry_run=True,
+                )
+
+        except FileNotFoundError:
+            # Git not available, try manual validation
+            return await self._validate_patch_manual(patch)
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(patch_file)
+            except Exception:
+                pass
+
+    async def _validate_patch_manual(self, patch: str) -> PatchResult:
+        """Manually validate a patch without git."""
+        operations = self._parse_patch(patch)
+        errors = []
+
+        for op in operations:
+            full_path = self.workspace_root / op.path
+
+            if op.operation == "update":
+                if not full_path.exists():
+                    errors.append(f"File does not exist: {op.path}")
+
+            elif op.operation == "create":
+                if full_path.exists():
+                    errors.append(f"File already exists: {op.path}")
+
+            elif op.operation == "delete":
+                if not full_path.exists():
+                    errors.append(f"File does not exist: {op.path}")
+
+        if errors:
+            return PatchResult(
+                success=False,
+                message="Patch validation failed",
+                errors=errors,
+                dry_run=True,
+            )
+
+        return PatchResult(
+            success=True,
+            message="Patch validation successful (manual check)",
+            files_modified=[op.path for op in operations],
+            dry_run=True,
+        )
+
+    async def _apply_patch(self, patch: str) -> PatchResult:
+        """Apply a patch to the workspace."""
+        # Write patch to temporary file
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".patch",
+            delete=False,
+        ) as f:
+            f.write(patch)
+            patch_file = f.name
+
+        try:
+            # Run git apply
+            proc = await asyncio.create_subprocess_exec(
+                "git",
+                "apply",
+                patch_file,
+                cwd=str(self.workspace_root),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+
+            if proc.returncode == 0:
+                operations = self._parse_patch(patch)
+                return PatchResult(
+                    success=True,
+                    message="Patch applied successfully",
+                    files_modified=[op.path for op in operations],
+                    dry_run=False,
+                )
+            else:
+                error_msg = stderr.decode("utf-8").strip()
+                return PatchResult(
+                    success=False,
+                    message="Failed to apply patch",
+                    errors=[error_msg] if error_msg else ["Patch application failed"],
+                    dry_run=False,
+                )
+
+        except FileNotFoundError:
+            # Git not available, try manual application
+            return await self._apply_patch_manual(patch)
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(patch_file)
+            except Exception:
+                pass
+
+    async def _apply_patch_manual(self, patch: str) -> PatchResult:
+        """Manually apply a patch without git (limited support)."""
+        return PatchResult(
+            success=False,
+            message="Manual patch application not supported. Please install git.",
+            errors=["Git is required for patch application"],
+            dry_run=False,
+        )
+
+    def get_tool_definition(self) -> Dict[str, Any]:
+        """Get the Open Responses tool definition for apply_patch."""
+        return {
+            "type": "apply_patch",
+        }

superqode/providers/openresponses/tools/code_interpreter.py

@@ -0,0 +1,290 @@
+"""
+Code Interpreter Tool for Open Responses.
+
+Executes code in a sandboxed environment. Supports:
+- Python execution
+- Shell command execution
+- Test running
+
+Features:
+- Timeout control
+- Output capture
+- Error handling
+- Resource limits
+
+Usage:
+    tool = CodeInterpreterTool(workspace_root="/path/to/project")
+    result = await tool.execute("print('Hello, World!')", language="python")
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ExecutionResult:
+    """Result of code execution."""
+
+    success: bool
+    output: str
+    error: str = ""
+    exit_code: int = 0
+    timed_out: bool = False
+
+
+class CodeInterpreterTool:
+    """
+    Code interpreter tool for Open Responses.
+
+    Executes code in a controlled environment with timeout
+    and output capture.
+
+    Args:
+        workspace_root: Root directory for execution
+        timeout: Maximum execution time in seconds
+        max_output_size: Maximum output size in bytes
+    """
+
+    def __init__(
+        self,
+        workspace_root: str,
+        timeout: float = 60.0,
+        max_output_size: int = 100 * 1024,  # 100KB
+    ):
+        self.workspace_root = Path(workspace_root).resolve()
+        self.timeout = timeout
+        self.max_output_size = max_output_size
+
+    async def execute(
+        self,
+        code: str,
+        language: str = "python",
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """
+        Execute code in the specified language.
+
+        Args:
+            code: The code to execute
+            language: Programming language ("python", "shell", "bash")
+            timeout: Override default timeout
+
+        Returns:
+            Dict with success status, output, and details
+        """
+        use_timeout = timeout if timeout is not None else self.timeout
+
+        if language in ("python", "python3"):
+            result = await self._execute_python(code, use_timeout)
+        elif language in ("shell", "bash", "sh"):
+            result = await self._execute_shell(code, use_timeout)
+        else:
+            return {
+                "success": False,
+                "output": "",
+                "error": f"Unsupported language: {language}",
+                "exit_code": 1,
+            }
+
+        return {
+            "success": result.success,
+            "output": result.output,
+            "error": result.error,
+            "exit_code": result.exit_code,
+            "timed_out": result.timed_out,
+        }
+
+    async def run_tests(
+        self,
+        test_command: Optional[str] = None,
+        test_file: Optional[str] = None,
+        timeout: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        """
+        Run tests in the workspace.
+
+        Args:
+            test_command: Custom test command
+            test_file: Specific test file to run
+            timeout: Override default timeout
+
+        Returns:
+            Dict with test results
+        """
+        use_timeout = timeout if timeout is not None else self.timeout
+
+        # Determine test command
+        if test_command:
+            cmd = test_command
+        elif test_file:
+            cmd = f"python -m pytest {test_file} -v"
+        else:
+            # Auto-detect test framework
+            cmd = await self._detect_test_command()
+
+        result = await self._execute_shell(cmd, use_timeout)
+
+        return {
+            "success": result.success,
+            "output": result.output,
+            "error": result.error,
+            "exit_code": result.exit_code,
+            "timed_out": result.timed_out,
+            "command": cmd,
+        }
+
+    async def _execute_python(
+        self,
+        code: str,
+        timeout: float,
+    ) -> ExecutionResult:
+        """Execute Python code."""
+        # Write code to temporary file
+        with tempfile.NamedTemporaryFile(
+            mode="w",
+            suffix=".py",
+            delete=False,
+            dir=str(self.workspace_root),
+        ) as f:
+            f.write(code)
+            script_file = f.name
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                "python3",
+                script_file,
+                cwd=str(self.workspace_root),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env={**os.environ, "PYTHONUNBUFFERED": "1"},
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    proc.communicate(),
+                    timeout=timeout,
+                )
+                timed_out = False
+            except asyncio.TimeoutError:
+                proc.kill()
+                await proc.wait()
+                return ExecutionResult(
+                    success=False,
+                    output="",
+                    error=f"Execution timed out after {timeout} seconds",
+                    exit_code=-1,
+                    timed_out=True,
+                )
+
+            output = stdout.decode("utf-8", errors="replace")
+            error = stderr.decode("utf-8", errors="replace")
+
+            # Truncate if needed
+            if len(output) > self.max_output_size:
+                output = output[: self.max_output_size] + "\n[Output truncated]"
+            if len(error) > self.max_output_size:
+                error = error[: self.max_output_size] + "\n[Error output truncated]"
+
+            return ExecutionResult(
+                success=proc.returncode == 0,
+                output=output,
+                error=error,
+                exit_code=proc.returncode or 0,
+                timed_out=False,
+            )
+
+        finally:
+            # Clean up temp file
+            try:
+                os.unlink(script_file)
+            except Exception:
+                pass
+
+    async def _execute_shell(
+        self,
+        command: str,
+        timeout: float,
+    ) -> ExecutionResult:
+        """Execute a shell command."""
+        try:
+            proc = await asyncio.create_subprocess_shell(
+                command,
+                cwd=str(self.workspace_root),
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                env=os.environ.copy(),
+            )
+
+            try:
+                stdout, stderr = await asyncio.wait_for(
+                    proc.communicate(),
+                    timeout=timeout,
+                )
+                timed_out = False
+            except asyncio.TimeoutError:
+                proc.kill()
+                await proc.wait()
+                return ExecutionResult(
+                    success=False,
+                    output="",
+                    error=f"Execution timed out after {timeout} seconds",
+                    exit_code=-1,
+                    timed_out=True,
+                )
+
+            output = stdout.decode("utf-8", errors="replace")
+            error = stderr.decode("utf-8", errors="replace")
+
+            # Truncate if needed
+            if len(output) > self.max_output_size:
+                output = output[: self.max_output_size] + "\n[Output truncated]"
+            if len(error) > self.max_output_size:
+                error = error[: self.max_output_size] + "\n[Error output truncated]"
+
+            return ExecutionResult(
+                success=proc.returncode == 0,
+                output=output,
+                error=error,
+                exit_code=proc.returncode or 0,
+                timed_out=False,
+            )
+
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                output="",
+                error=str(e),
+                exit_code=1,
+                timed_out=False,
+            )
+
+    async def _detect_test_command(self) -> str:
+        """Detect the appropriate test command for the workspace."""
+        # Check for common test configurations
+        if (self.workspace_root / "pytest.ini").exists():
+            return "python -m pytest -v"
+        if (self.workspace_root / "pyproject.toml").exists():
+            return "python -m pytest -v"
+        if (self.workspace_root / "setup.py").exists():
+            return "python -m pytest -v"
+        if (self.workspace_root / "package.json").exists():
+            return "npm test"
+        if (self.workspace_root / "Cargo.toml").exists():
+            return "cargo test"
+        if (self.workspace_root / "go.mod").exists():
+            return "go test ./..."
+
+        # Default to pytest
+        return "python -m pytest -v"
+
+    def get_tool_definition(self) -> Dict[str, Any]:
+        """Get the Open Responses tool definition for code_interpreter."""
+        return {
+            "type": "code_interpreter",
+        }