sky-dev 0.0.5__py3-none-any.whl

sky/tools/fs_tools.py

@@ -0,0 +1,139 @@
+"""Filesystem manipulation tools."""
+
+import os
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import patch
+
+from sky.tools.registry import RiskTier, register_tool
+
+
+def _resolve_and_validate_path(path_str: str) -> Path:
+    """Resolve a path and ensure it stays within the current working directory."""
+    cwd = Path.cwd().resolve()
+    target_path = Path(path_str).expanduser().resolve()
+    
+    try:
+        # Check if the target_path is relative to cwd (prevents traversal)
+        target_path.relative_to(cwd)
+    except ValueError:
+        raise PermissionError(f"Path traversal attempt blocked: {path_str} resolves outside of project root {cwd}")
+        
+    return target_path
+
+
+@register_tool("read_file", "Read content from a file safely.", RiskTier.SAFE)
+def read_file(path: str, offset: Optional[int] = None, limit: Optional[int] = None) -> str:
+    """Read contents of a file with optional line ranges.
+    
+    Args:
+        path: Path to the file to read.
+        offset: Optional starting line number (1-indexed).
+        limit: Optional maximum number of lines to read.
+    """
+    target = _resolve_and_validate_path(path)
+    if not target.exists() or not target.is_file():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    with open(target, "r", encoding="utf-8", errors="replace") as f:
+        lines = f.readlines()
+        
+    if offset is not None:
+        if offset < 1:
+            raise ValueError("Offset must be >= 1 (1-indexed).")
+        lines = lines[offset - 1:]
+        
+    if limit is not None:
+        if limit < 1:
+            raise ValueError("Limit must be >= 1.")
+        lines = lines[:limit]
+        
+    return "".join(lines)
+
+
+@register_tool("write_file", "Write content to a file atomically.", RiskTier.DESTRUCTIVE)
+def write_file(path: str, content: str) -> Dict[str, Any]:
+    """Write complete content to a file.
+    
+    Args:
+        path: Path to the file to write.
+        content: The complete content to write.
+    """
+    target = _resolve_and_validate_path(path)
+    target.parent.mkdir(parents=True, exist_ok=True)
+    
+    fd, temp_path = tempfile.mkstemp(dir=target.parent, prefix=".tmp_sky_")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            f.write(content)
+        os.replace(temp_path, target)
+    except Exception as e:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+        raise OSError(f"Failed to write file atomically: {e}")
+
+    return {
+        "path": str(target.relative_to(Path.cwd())),
+        "bytes_written": len(content.encode("utf-8")),
+        "success": True
+    }
+
+
+@register_tool("edit_file", "Apply a unified diff to a file.", RiskTier.DESTRUCTIVE)
+def edit_file(path: str, diff: str) -> Dict[str, Any]:
+    """Edit a file by applying a unified diff patch.
+    
+    Args:
+        path: Path to the file to edit.
+        diff: The unified diff string to apply.
+    """
+    target = _resolve_and_validate_path(path)
+    if not target.exists():
+        raise FileNotFoundError(f"Cannot edit non-existent file: {path}")
+
+    patch_set = patch.fromstring(diff.encode("utf-8"))
+    if not patch_set or not patch_set.items:
+        raise ValueError("Invalid unified diff provided.")
+
+    if len(patch_set.items) > 1:
+        raise ValueError("Diff contains multiple files. Use edit_file for one file at a time.")
+        
+    import shutil
+    with tempfile.TemporaryDirectory(dir=target.parent) as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        temp_target = temp_dir_path / target.name
+        
+        # Copy original to temp
+        shutil.copy2(target, temp_target)
+            
+        # Ensure the patch set uses the basename so it patches the file inside temp_dir
+        p = patch_set.items[0]
+        p.source = target.name.encode("utf-8")
+        p.target = target.name.encode("utf-8")
+        
+        # Apply patch in temp directory
+        success = patch_set.apply(strip=0, root=str(temp_dir_path))
+        if not success:
+            raise RuntimeError("Failed to apply diff patch cleanly.")
+            
+        # Atomic replace
+        os.replace(temp_target, target)
+
+    added = 0
+    removed = 0
+    for item in patch_set.items:
+        for hunk in item.hunks:
+            for line in hunk.text:
+                if line.startswith(b"+") and not line.startswith(b"+++"):
+                    added += 1
+                elif line.startswith(b"-") and not line.startswith(b"---"):
+                    removed += 1
+
+    return {
+        "path": str(target.relative_to(Path.cwd())),
+        "lines_added": added,
+        "lines_removed": removed,
+        "success": True
+    }

sky/tools/git_tools.py

@@ -0,0 +1,139 @@
+"""Git integration tools."""
+
+import os
+import subprocess
+from typing import Any, Dict, List, Optional
+
+from sky.tools.registry import RiskTier, register_tool
+
+
+def _run_git(args: List[str]) -> subprocess.CompletedProcess:
+    """Helper to run git commands safely."""
+    try:
+        return subprocess.run(["git"] + args, capture_output=True, text=True, check=True)
+    except subprocess.CalledProcessError as e:
+        raise RuntimeError(f"Git command failed: {e.stderr}")
+    except FileNotFoundError:
+        raise RuntimeError("Git executable not found in PATH.")
+
+
+@register_tool("git_diff", "Get git diffs for staged and unstaged changes.", RiskTier.SAFE)
+def git_diff() -> Dict[str, Any]:
+    """Get current git diff (unstaged and staged changes)."""
+    unstaged = subprocess.run(["git", "diff"], capture_output=True, text=True).stdout
+    staged = subprocess.run(["git", "diff", "--staged"], capture_output=True, text=True).stdout
+    
+    f_changed = subprocess.run(["git", "diff", "--name-only"], capture_output=True, text=True).stdout.splitlines()
+    f_staged = subprocess.run(["git", "diff", "--staged", "--name-only"], capture_output=True, text=True).stdout.splitlines()
+    
+    return {
+        "unstaged": unstaged,
+        "staged": staged,
+        "files_changed": [f for f in f_changed if f],
+        "files_staged": [f for f in f_staged if f],
+    }
+
+
+@register_tool("git_log", "Get recent git commit history.", RiskTier.SAFE)
+def git_log(limit: int = 10) -> List[Dict[str, Any]]:
+    """Get git log history.
+    
+    Args:
+        limit: Number of commits to return.
+    """
+    fmt = "%H|%an|%ae|%at|%s"
+    try:
+        result = _run_git(["log", f"--pretty=format:{fmt}", f"-n{limit}"])
+    except RuntimeError:
+        return []
+        
+    commits = []
+    for line in result.stdout.splitlines():
+        if not line:
+            continue
+        parts = line.split("|", 4)
+        if len(parts) == 5:
+            commits.append({
+                "hash": parts[0],
+                "author_name": parts[1],
+                "author_email": parts[2],
+                "timestamp": parts[3],
+                "subject": parts[4]
+            })
+    return commits
+
+
+@register_tool("git_commit", "Commit changes to git repository.", RiskTier.DESTRUCTIVE)
+def git_commit(message: str, files: Optional[List[str]] = None) -> Dict[str, Any]:
+    """Commit files to the repository.
+    
+    Args:
+        message: Commit message.
+        files: Optional list of files to commit. If None, commits currently staged changes.
+    """
+    if files:
+        _run_git(["add"] + files)
+        
+    try:
+        _run_git(["commit", "-m", message])
+        hash_result = _run_git(["rev-parse", "HEAD"])
+        return {
+            "hash": hash_result.stdout.strip(),
+            "message": message,
+            "files_committed": files or [],
+            "success": True
+        }
+    except RuntimeError as e:
+        return {
+            "hash": "",
+            "message": message,
+            "files_committed": [],
+            "success": False,
+            "error": str(e)
+        }
+
+
+@register_tool("git_branch", "Create, switch, or view branches.", RiskTier.DESTRUCTIVE)
+def git_branch(name: str, checkout: bool = False) -> Dict[str, Any]:
+    """Create or checkout a git branch.
+    
+    Args:
+        name: Name of the branch.
+        checkout: Whether to switch to the branch.
+    """
+    if not os.path.exists(".git"):
+        raise RuntimeError("Not a git repository (no .git directory found).")
+        
+    branches = _run_git(["branch", "--list", name]).stdout.strip()
+    branch_exists = bool(branches)
+    
+    created = False
+    switched = False
+    
+    try:
+        if checkout:
+            if branch_exists:
+                _run_git(["checkout", name])
+            else:
+                _run_git(["checkout", "-b", name])
+                created = True
+            switched = True
+        else:
+            if not branch_exists:
+                _run_git(["branch", name])
+                created = True
+                
+        return {
+            "branch": name,
+            "created": created,
+            "switched": switched,
+            "success": True
+        }
+    except RuntimeError as e:
+        return {
+            "branch": name,
+            "created": False,
+            "switched": False,
+            "success": False,
+            "error": str(e)
+        }

sky/tools/registry.py

@@ -0,0 +1,219 @@
+"""Tool registry for defining and managing agent capabilities."""
+
+import inspect
+import re
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, List, Optional, get_args, get_origin
+
+
+class RiskTier(str, Enum):
+    """Classification of tool execution risk."""
+    
+    SAFE = "safe"
+    DESTRUCTIVE = "destructive"
+
+
+@dataclass
+class ToolDefinition:
+    """Definition of an agent tool."""
+    
+    name: str
+    description: str
+    risk_tier: RiskTier
+    func: Callable[..., Any]
+    args_schema: Dict[str, Any]
+    required_args: List[str] = field(default_factory=list)
+
+    def to_openai_schema(self) -> Dict[str, Any]:
+        """Convert the tool definition to OpenAI's function calling schema."""
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": self.args_schema,
+                    "required": self.required_args,
+                },
+            },
+        }
+
+
+class ToolRegistry:
+    """Singleton registry for all available tools."""
+    
+    _instance: Optional["ToolRegistry"] = None
+    _tools: Dict[str, ToolDefinition]
+
+    def __new__(cls) -> "ToolRegistry":
+        if cls._instance is None:
+            cls._instance = super(ToolRegistry, cls).__new__(cls)
+            cls._instance._tools = {}
+        return cls._instance
+
+    @classmethod
+    def _type_to_json_schema(cls, type_hint: Any) -> str:
+        """Convert a Python type hint to a JSON Schema type string."""
+        if type_hint == str:
+            return "string"
+        elif type_hint == int:
+            return "integer"
+        elif type_hint == float:
+            return "number"
+        elif type_hint == bool:
+            return "boolean"
+        elif type_hint == dict or type_hint == Dict:
+            return "object"
+        elif type_hint == list or type_hint == List:
+            return "array"
+        elif type_hint == Any:
+            return "string"  # Fallback for Any
+            
+        origin = get_origin(type_hint)
+        if origin is not None:
+            # Handle Optional[...] which is Union[..., NoneType]
+            import typing
+            is_union = False
+            try:
+                import types
+                if hasattr(types, "UnionType") and isinstance(type_hint, types.UnionType):
+                    is_union = True
+            except ImportError:
+                pass
+                
+            if origin is typing.Union or is_union or type_hint.__class__.__name__ in ('_UnionGenericAlias', 'UnionType', 'Union') or "Union" in str(type_hint):
+                args = get_args(type_hint)
+                # Find the non-None type
+                for arg in args:
+                    if arg is not type(None):
+                        return cls._type_to_json_schema(arg)
+            
+            # Handle List, Dict generics
+            if origin == list or origin == typing.List or str(origin).endswith("list"):
+                return "array"
+            if origin == dict or origin == typing.Dict or str(origin).endswith("dict"):
+                return "object"
+                
+        return "string"  # Default fallback
+
+    @classmethod
+    def _extract_param_description(cls, docstring: Optional[str], param_name: str) -> Optional[str]:
+        """Extract parameter description from the docstring Args: section."""
+        if not docstring:
+            return None
+            
+        # Look for 'Args:' or 'Parameters:' section
+        args_match = re.search(r"(?:Args|Parameters):\s*\n(.*?)(?:\n\s*\n|\Z)", docstring, re.DOTALL)
+        if not args_match:
+            return None
+            
+        args_section = args_match.group(1)
+        
+        # Look for the specific parameter description
+        param_pattern = re.compile(rf"^\s*{param_name}\s*(?:\([^)]+\))?\s*:\s*(.*?)(?=\n\s*\w+\s*(?:\([^)]+\))?\s*:|\Z)", re.DOTALL | re.MULTILINE)
+        
+        param_match = param_pattern.search(args_section)
+        if param_match:
+            desc = param_match.group(1).replace("\n", " ").strip()
+            return re.sub(r"\s+", " ", desc)
+            
+        return None
+
+    def register(self, name: str, description: str, risk_tier: RiskTier) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+        """Decorator to register a function as a tool."""
+        def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+            sig = inspect.signature(func)
+            docstring = inspect.getdoc(func)
+            
+            args_schema: Dict[str, Any] = {}
+            required_args: List[str] = []
+            
+            for param_name, param in sig.parameters.items():
+                if param_name == "self" or param_name == "cls":
+                    continue
+                    
+                json_type = self._type_to_json_schema(param.annotation)
+                param_desc = self._extract_param_description(docstring, param_name)
+                
+                param_schema: Dict[str, Any] = {"type": json_type}
+                if param_desc:
+                    param_schema["description"] = param_desc
+                    
+                args_schema[param_name] = param_schema
+                
+                if param.default == inspect.Parameter.empty:
+                    required_args.append(param_name)
+                    
+            tool_def = ToolDefinition(
+                name=name,
+                description=description,
+                risk_tier=risk_tier,
+                func=func,
+                args_schema=args_schema,
+                required_args=required_args,
+            )
+            
+            self._tools[name] = tool_def
+            
+            import os
+            if os.getenv("SKY_VERBOSE", "").lower() == "true":
+                from rich.console import Console
+                import json
+                Console().print(f"[dim]Schema for {name}: {json.dumps(tool_def.to_openai_schema(), indent=2)}[/dim]")
+                
+            return func
+            
+        return decorator
+
+    def get(self, name: str) -> Optional[ToolDefinition]:
+        """Get a tool definition by name."""
+        return self._tools.get(name)
+
+    def list(self, risk_tier: Optional[RiskTier] = None) -> List[ToolDefinition]:
+        """List all tools, optionally filtered by risk tier."""
+        if risk_tier:
+            return [t for t in self._tools.values() if t.risk_tier == risk_tier]
+        return list(self._tools.values())
+
+    def get_schemas(self, risk_tier: Optional[RiskTier] = None) -> List[Dict[str, Any]]:
+        """Get OpenAI function schemas for all tools, optionally filtered."""
+        tools = self.list(risk_tier)
+        return [t.to_openai_schema() for t in tools]
+
+    def execute(self, name: str, **kwargs: Any) -> Any:
+        """Execute a tool by name with the given arguments."""
+        tool = self.get(name)
+        if not tool:
+            raise ValueError(f"Tool not found: {name}")
+        return tool.func(**kwargs)
+
+
+# Global registry instance and helper functions
+_registry = ToolRegistry()
+
+
+def register_tool(name: str, description: str, risk_tier: RiskTier) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Register a tool with the global registry."""
+    return _registry.register(name, description, risk_tier)
+
+
+def get_tool(name: str) -> Optional[ToolDefinition]:
+    """Get a tool from the global registry."""
+    return _registry.get(name)
+
+
+def list_tools(risk_tier: Optional[RiskTier] = None) -> List[ToolDefinition]:
+    """List tools from the global registry."""
+    return _registry.list(risk_tier)
+
+
+def get_tools_by_risk(risk_tier: RiskTier) -> List[ToolDefinition]:
+    """Get tools matching a specific risk tier."""
+    return _registry.list(risk_tier)
+
+
+def get_tool_schemas(risk_tier: Optional[RiskTier] = None) -> List[Dict[str, Any]]:
+    """Get OpenAI schemas from the global registry."""
+    return _registry.get_schemas(risk_tier)

sky/tools/search_tools.py

@@ -0,0 +1,128 @@
+"""Search tools utilizing ripgrep."""
+
+import json
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from sky.tools.registry import RiskTier, register_tool
+
+
+@register_tool("grep", "Search for a pattern in files using ripgrep.", RiskTier.SAFE)
+def grep(pattern: str, path: Optional[str] = None, glob_filter: Optional[str] = None) -> List[Dict[str, Any]]:
+    """Search for text patterns using ripgrep.
+    
+    Args:
+        pattern: The regex pattern to search for.
+        path: Optional specific path or directory to search in.
+        glob_filter: Optional glob pattern to filter files (e.g. '*.py').
+    """
+    cmd = ["rg", "--json", pattern]
+    if glob_filter:
+        cmd.extend(["-g", glob_filter])
+    if path:
+        cmd.append(path)
+        
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, check=False)
+        
+        matches = []
+        for line in result.stdout.splitlines():
+            if not line.strip():
+                continue
+            try:
+                data = json.loads(line)
+                if data.get("type") == "match":
+                    match_data = data.get("data", {})
+                    matches.append({
+                        "file": match_data.get("path", {}).get("text", ""),
+                        "line_number": match_data.get("line_number"),
+                        "line_text": match_data.get("lines", {}).get("text", ""),
+                        "submatches": match_data.get("submatches", [])
+                    })
+            except json.JSONDecodeError:
+                continue
+                
+        return matches
+    except FileNotFoundError:
+        raise RuntimeError("rg (ripgrep) not found. Please install ripgrep.")
+
+
+@register_tool("glob", "Find files matching a glob pattern.", RiskTier.SAFE)
+def glob(pattern: str) -> List[str]:
+    """Find files using a glob pattern, respecting .gitignore.
+    
+    Args:
+        pattern: Glob pattern to match files.
+    """
+    try:
+        cmd = ["rg", "--files", "-g", pattern]
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        paths = [p for p in result.stdout.splitlines() if p.strip()]
+        return paths
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        paths = []
+        cwd = Path.cwd()
+        exclude = {".git", "node_modules", "venv", "__pycache__", ".sky"}
+        
+        for p in cwd.rglob(pattern):
+            if p.is_file():
+                if not any(part in exclude for part in p.parts):
+                    try:
+                        paths.append(str(p.relative_to(cwd)))
+                    except ValueError:
+                        pass
+        return paths
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+@register_tool(
+    name="search_codebase",
+    description="Semantically search the repository for relevant code snippets, functions, or concepts. Use this for high-level queries like 'where is Docker handled' or 'how does approval work'.",
+    risk_tier=RiskTier.SAFE
+)
+def search_codebase(query: str, top_k: int = 3) -> dict:
+    """
+    Search the codebase semantically using vector embeddings.
+    
+    Args:
+        query: The search query or concept to find
+        top_k: Number of results to return (default: 3)
+    
+    Returns:
+        dict with 'results' list and 'total' count
+    """
+    try:
+        from sky.memory.vectorstore import get_vector_store
+        # Get vector store
+        store = get_vector_store(Path.home() / ".sky" / "lancedb")
+        
+        # Search
+        results = store.search(query, top_k=top_k)
+        
+        # Format results
+        formatted_results = []
+        for r in results:
+            formatted_results.append({
+                "file_path": r["file_path"],
+                "content": r["content"][:500] + ("..." if len(r["content"]) > 500 else ""),
+                "score": round(1 - r["score"], 3),  # Convert distance to similarity
+                "language": r.get("language", "text"),
+            })
+        
+        return {
+            "query": query,
+            "total": len(formatted_results),
+            "results": formatted_results,
+        }
+        
+    except Exception as e:
+        logger.error(f"Search codebase error: {e}")
+        return {
+            "query": query,
+            "total": 0,
+            "results": [],
+            "error": str(e),
+        }

sky/tools/shell_tools.py

@@ -0,0 +1,73 @@
+"""Shell execution tools with Docker sandboxing."""
+
+import os
+import subprocess
+from typing import Any, Dict
+
+from sky.config import load_config
+from sky.tools.registry import RiskTier, register_tool
+
+
+@register_tool("bash", "Execute a bash command in a sandboxed Docker container.", RiskTier.DESTRUCTIVE)
+def bash(command: str, timeout: int = 60) -> Dict[str, Any]:
+    """Run a bash command in a secure Docker sandbox.
+    
+    Args:
+        command: The bash command to execute.
+        timeout: Maximum execution time in seconds.
+    """
+    config = load_config()
+    
+    docker_image = config.docker_image
+    # HARD-BLOCK constraint
+    docker_network = "none" 
+    
+    workspace_dir = os.path.abspath(os.getcwd())
+    
+    docker_cmd = [
+        "docker", "run", "--rm",
+        f"--network={docker_network}",
+        "--cap-drop=ALL",
+        "--user=1000:1000",
+        "-v", f"{workspace_dir}:/workspace:rw",
+        "-w", "/workspace",
+        docker_image,
+        "bash", "-c", command
+    ]
+    
+    try:
+        result = subprocess.run(
+            docker_cmd,
+            capture_output=True,
+            text=True,
+            timeout=timeout,
+            check=False
+        )
+        return {
+            "stdout": result.stdout,
+            "stderr": result.stderr,
+            "exit_code": result.returncode,
+            "success": result.returncode == 0
+        }
+    except subprocess.TimeoutExpired as e:
+        return {
+            "stdout": e.stdout.decode() if isinstance(e.stdout, bytes) else (e.stdout or ""),
+            "stderr": e.stderr.decode() if isinstance(e.stderr, bytes) else (e.stderr or ""),
+            "exit_code": 124,
+            "success": False,
+            "error": "Timeout expired"
+        }
+    except FileNotFoundError:
+        return {
+            "stdout": "",
+            "stderr": "Docker executable not found. Ensure Docker is installed and in PATH.",
+            "exit_code": -1,
+            "success": False
+        }
+    except Exception as e:
+        return {
+            "stdout": "",
+            "stderr": str(e),
+            "exit_code": -1,
+            "success": False
+        }