skilllite 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

skilllite/sandbox/unified_executor.py

@@ -0,0 +1,359 @@
+"""
+Unified Executor - Single source of truth for all skill execution.
+
+This module provides the UnifiedExecutor class which handles all execution logic.
+It uses ExecutionContext to get configuration at runtime, ensuring that any
+changes to environment variables or context overrides are immediately reflected.
+
+Key Design Principles:
+1. Never use instance variables for configuration
+2. Always read from ExecutionContext at execution time
+3. Single command building logic
+4. Single subprocess execution logic
+"""
+
+import json
+import os
+import subprocess
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .base import ExecutionResult
+from .context import ExecutionContext
+
+
+class UnifiedExecutor:
+    """
+    Unified executor - all skill execution goes through this class.
+    
+    This class is stateless regarding configuration. All configuration
+    comes from ExecutionContext passed to each method.
+    """
+    
+    def __init__(self):
+        """Initialize the executor."""
+        from .skillbox import find_binary
+        self._binary_path = find_binary()
+        if not self._binary_path:
+            raise RuntimeError("skillbox binary not found")
+    
+    @property
+    def binary_path(self) -> str:
+        """Path to the skillbox binary."""
+        return self._binary_path
+    
+    @property
+    def is_available(self) -> bool:
+        """Check if skillbox is available."""
+        return self._binary_path is not None and os.path.exists(self._binary_path)
+    
+    def execute(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+        input_data: Dict[str, Any],
+        entry_point: Optional[str] = None,
+        args: Optional[List[str]] = None,
+    ) -> ExecutionResult:
+        """
+        Execute a skill with the given context.
+        
+        Args:
+            context: Execution context with all configuration
+            skill_dir: Path to the skill directory
+            input_data: Input data for the skill
+            entry_point: Optional specific script to execute
+            args: Optional command line arguments
+            
+        Returns:
+            ExecutionResult with output or error
+        """
+        if entry_point:
+            return self.exec_script(
+                context=context,
+                skill_dir=skill_dir,
+                script_path=entry_point,
+                input_data=input_data,
+                args=args,
+            )
+        
+        # Build command for skillbox run
+        cmd = self._build_run_command(context, skill_dir, input_data)
+        return self._run_subprocess(cmd, context, skill_dir)
+    
+    def exec_script(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+        script_path: str,
+        input_data: Dict[str, Any],
+        args: Optional[List[str]] = None,
+    ) -> ExecutionResult:
+        """
+        Execute a specific script directly.
+        
+        Args:
+            context: Execution context with all configuration
+            skill_dir: Path to the skill directory
+            script_path: Relative path to the script
+            input_data: Input data for the script
+            args: Optional command line arguments
+            
+        Returns:
+            ExecutionResult with output or error
+        """
+        # Convert JSON input to CLI args if no explicit args provided
+        if args is None and input_data:
+            args = self._convert_json_to_cli_args(input_data)
+        
+        # For Level 1/2 Python scripts, use direct execution for better performance
+        if script_path.endswith('.py') and context.sandbox_level != "3":
+            return self._exec_python_direct(context, skill_dir, script_path, args)
+        
+        # Build command for skillbox exec
+        cmd = self._build_exec_command(context, skill_dir, script_path, input_data, args)
+        return self._run_subprocess(cmd, context, skill_dir)
+    
+    def _build_run_command(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+        input_data: Dict[str, Any],
+    ) -> List[str]:
+        """Build command for skillbox run."""
+        # Convert to absolute path to avoid path issues
+        abs_skill_dir = Path(skill_dir).resolve()
+        cmd = [
+            self._binary_path,
+            "run",
+            str(abs_skill_dir),
+            json.dumps(input_data),
+        ]
+        
+        # Add sandbox level from context (NOT from instance variable)
+        cmd.extend(["--sandbox-level", context.sandbox_level])
+        
+        if context.allow_network:
+            cmd.append("--allow-network")
+        
+        cmd.extend(["--timeout", str(context.timeout)])
+        cmd.extend(["--max-memory", str(context.max_memory_mb)])
+        
+        return cmd
+    
+    def _build_exec_command(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+        script_path: str,
+        input_data: Dict[str, Any],
+        args: Optional[List[str]] = None,
+    ) -> List[str]:
+        """Build command for skillbox exec."""
+        # Convert to absolute path to avoid path issues
+        abs_skill_dir = Path(skill_dir).resolve()
+        cmd = [
+            self._binary_path,
+            "exec",
+            str(abs_skill_dir),
+            script_path,
+            json.dumps(input_data),
+        ]
+        
+        if args:
+            args_str = " ".join(args) if isinstance(args, list) else args
+            cmd.extend(["--args", args_str])
+        
+        # Add sandbox level from context (NOT from instance variable)
+        cmd.extend(["--sandbox-level", context.sandbox_level])
+        
+        if context.allow_network:
+            cmd.append("--allow-network")
+        
+        cmd.extend(["--timeout", str(context.timeout)])
+        cmd.extend(["--max-memory", str(context.max_memory_mb)])
+
+        return cmd
+
+    def _run_subprocess(
+        self,
+        cmd: List[str],
+        context: ExecutionContext,
+        skill_dir: Path,
+    ) -> ExecutionResult:
+        """Run subprocess with the given command."""
+        env = self._build_env(context, skill_dir)
+
+        try:
+            if context.sandbox_level == "3" and not context.confirmed:
+                # Level 3 without confirmation: allow stderr for prompts
+                result = subprocess.run(
+                    cmd,
+                    stdin=None,
+                    stdout=subprocess.PIPE,
+                    stderr=None,
+                    text=True,
+                    timeout=context.timeout,
+                    env=env,
+                )
+                return self._parse_output(result.stdout, "", result.returncode)
+            else:
+                # Level 1/2 or confirmed: capture all output
+                result = subprocess.run(
+                    cmd,
+                    capture_output=True,
+                    text=True,
+                    timeout=context.timeout,
+                    env=env,
+                )
+                return self._parse_output(result.stdout, result.stderr, result.returncode)
+
+        except subprocess.TimeoutExpired:
+            return ExecutionResult(
+                success=False,
+                error=f"Execution timed out after {context.timeout} seconds",
+                exit_code=-1,
+            )
+        except FileNotFoundError:
+            return ExecutionResult(
+                success=False,
+                error=f"skillbox binary not found at: {self._binary_path}",
+                exit_code=-1,
+            )
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                error=f"Execution failed: {str(e)}",
+                exit_code=-1,
+            )
+
+    def _build_env(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+    ) -> Dict[str, str]:
+        """Build environment variables for subprocess."""
+        env = os.environ.copy()
+
+        # Set sandbox level in environment (for consistency)
+        env["SKILLBOX_SANDBOX_LEVEL"] = context.sandbox_level
+        env["SKILLBOX_AUTO_APPROVE"] = "1" if context.auto_approve or context.confirmed else "1"
+
+        # Set skill-specific environment
+        env["SKILL_DIR"] = str(skill_dir)
+        env["SKILLBOX_TIMEOUT_SECS"] = str(context.timeout)
+        env["SKILLBOX_MAX_MEMORY_MB"] = str(context.max_memory_mb)
+
+        return env
+
+    def _exec_python_direct(
+        self,
+        context: ExecutionContext,
+        skill_dir: Path,
+        script_path: str,
+        args: Optional[List[str]] = None,
+    ) -> ExecutionResult:
+        """Execute Python script directly (for Level 1/2)."""
+        import sys
+
+        # Convert to absolute path to avoid path duplication issues
+        abs_skill_dir = Path(skill_dir).resolve()
+        full_script_path = abs_skill_dir / script_path
+
+        if not full_script_path.exists():
+            return ExecutionResult(
+                success=False,
+                error=f"Script not found: {full_script_path}",
+                exit_code=-1,
+            )
+
+        cmd = [sys.executable, str(full_script_path)]
+        if args:
+            cmd.extend(args)
+
+        env = self._build_env(context, abs_skill_dir)
+        env["PYTHONPATH"] = str(abs_skill_dir)
+
+        try:
+            # Don't set cwd to skill_dir - let scripts run from project root
+            # Scripts can use SKILL_DIR env var to find their own location
+            # This allows scripts like skill-creator to work with relative paths
+            # that are relative to the project root, not the skill directory
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=context.timeout,
+                env=env,
+            )
+            return self._parse_output(result.stdout, result.stderr, result.returncode)
+        except subprocess.TimeoutExpired:
+            return ExecutionResult(
+                success=False,
+                error=f"Execution timed out after {context.timeout} seconds",
+                exit_code=-1,
+            )
+        except Exception as e:
+            return ExecutionResult(
+                success=False,
+                error=f"Execution failed: {str(e)}",
+                exit_code=-1,
+            )
+
+    def _convert_json_to_cli_args(self, input_data: Dict[str, Any]) -> List[str]:
+        """Convert JSON input to CLI arguments.
+
+        Delegates to the shared utility function that properly handles
+        positional arguments like 'skill_name'.
+        """
+        from .utils import convert_json_to_cli_args
+        return convert_json_to_cli_args(input_data)
+
+    def _parse_output(
+        self,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+    ) -> ExecutionResult:
+        """Parse subprocess output into ExecutionResult."""
+        combined = stdout + stderr
+
+        # Try to parse JSON output
+        try:
+            # Look for JSON in output
+            for line in combined.split('\n'):
+                line = line.strip()
+                if line.startswith('{') and line.endswith('}'):
+                    data = json.loads(line)
+                    if isinstance(data, dict):
+                        return ExecutionResult(
+                            success=returncode == 0,
+                            output=data,
+                            exit_code=returncode,
+                            stdout=stdout,
+                            stderr=stderr,
+                        )
+        except json.JSONDecodeError:
+            pass
+
+        # Return as plain text
+        if returncode == 0:
+            return ExecutionResult(
+                success=True,
+                output={"result": stdout.strip()} if stdout.strip() else None,
+                exit_code=returncode,
+                stdout=stdout,
+                stderr=stderr,
+            )
+        else:
+            error_msg = stderr.strip() if stderr.strip() else stdout.strip()
+            return ExecutionResult(
+                success=False,
+                error=f"Skill execution failed with exit code {returncode}: {error_msg}",
+                exit_code=returncode,
+                stdout=stdout,
+                stderr=stderr,
+            )
+
+
+__all__ = ["UnifiedExecutor"]

{skilllite-0.1.0.dist-info → skilllite-0.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skilllite
-Version: 0.1.0
+Version: 0.1.2
 Summary: A lightweight Skills execution engine with LLM integration for LLM agents
 Author-email: SkillLite Team <skilllite@example.com>
 License: MIT
@@ -32,10 +32,16 @@ Provides-Extra: anthropic
 Requires-Dist: anthropic>=0.18.0; extra == "anthropic"
 Provides-Extra: mcp
 Requires-Dist: mcp>=1.0.0; extra == "mcp"
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == "langchain"
+Provides-Extra: llamaindex
+Requires-Dist: llama-index-core>=0.10.0; extra == "llamaindex"
 Provides-Extra: all
 Requires-Dist: openai>=1.0.0; extra == "all"
 Requires-Dist: anthropic>=0.18.0; extra == "all"
 Requires-Dist: mcp>=1.0.0; extra == "all"
+Requires-Dist: langchain-core>=0.1.0; extra == "all"
+Requires-Dist: llama-index-core>=0.10.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
@@ -288,6 +294,150 @@ Enum for LLM provider formats:
 - `ToolFormat.CLAUDE`
 - `ToolFormat.OPENAI`
 
+## Framework Adapters
+
+SkillLite provides adapters for popular AI frameworks with security confirmation support.
+
+### LangChain Integration
+
+For LangChain/LangGraph integration, we recommend using the dedicated **[langchain-skilllite](https://pypi.org/project/langchain-skilllite/)** package:
+
+```bash
+pip install langchain-skilllite
+```
+
+```python
+from langchain_skilllite import SkillLiteToolkit
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+
+# Load all skills from a directory as LangChain tools
+tools = SkillLiteToolkit.from_directory("./skills")
+
+# Create a LangGraph agent
+agent = create_react_agent(ChatOpenAI(model="gpt-4"), tools)
+
+# Run the agent
+result = agent.invoke({
+    "messages": [("user", "Convert 'hello world' to uppercase")]
+})
+```
+
+With security confirmation (sandbox_level=3):
+
+```python
+def confirm_execution(report: str, scan_id: str) -> bool:
+    print(report)
+    return input("Continue? [y/N]: ").lower() == 'y'
+
+tools = SkillLiteToolkit.from_directory(
+    "./skills",
+    sandbox_level=3,  # 1=no sandbox, 2=sandbox only, 3=sandbox+scan
+    confirmation_callback=confirm_execution
+)
+```
+
+For more details, see the [langchain-skilllite documentation](../langchain-skilllite/README.md).
+
+**Alternative**: You can also use the built-in adapter:
+
+```python
+from skilllite import SkillManager
+from skilllite.core.adapters.langchain import SkillLiteToolkit
+
+manager = SkillManager(skills_dir="./skills")
+tools = SkillLiteToolkit.from_manager(manager).get_tools()
+```
+
+### LlamaIndex Integration
+
+```python
+from skilllite import SkillManager
+from skilllite.core.adapters.llamaindex import SkillLiteToolSpec
+
+manager = SkillManager(skills_dir="./skills")
+
+# Basic usage
+tool_spec = SkillLiteToolSpec.from_manager(manager)
+tools = tool_spec.to_tool_list()
+
+# With security confirmation
+def confirm(report: str, scan_id: str) -> bool:
+    print(report)
+    return input("Continue? [y/N]: ").lower() == 'y'
+
+tool_spec = SkillLiteToolSpec.from_manager(
+    manager,
+    sandbox_level=3,
+    confirmation_callback=confirm
+)
+
+# Use with LlamaIndex agent
+from llama_index.core.agent import ReActAgent
+agent = ReActAgent.from_tools(tools, llm=llm)
+```
+
+### Security Levels
+
+| Level | Description |
+|-------|-------------|
+| 1 | No sandbox - direct execution |
+| 2 | Sandbox isolation only |
+| 3 | Sandbox + static security scan (requires confirmation for high-severity issues) |
+
+## OpenCode Integration
+
+SkillLite can be integrated with [OpenCode](https://github.com/opencode-ai/opencode) as an MCP (Model Context Protocol) server, providing secure sandbox execution capabilities.
+
+### Quick Setup
+
+```bash
+# Install with MCP support
+pip install skilllite[mcp]
+
+# One-command setup for OpenCode
+skilllite init-opencode
+
+# Start OpenCode
+opencode
+```
+
+The `init-opencode` command automatically:
+- Detects the best way to start the MCP server (uvx, pipx, skilllite, or python)
+- Creates `opencode.json` with optimal configuration
+- Generates `.opencode/skills/skilllite/SKILL.md` with usage instructions
+- Discovers your pre-defined skills
+
+### Available MCP Tools
+
+| Tool | Description |
+|------|-------------|
+| `skilllite_list_skills` | List all available skills |
+| `skilllite_get_skill_info` | Get skill details and input schema |
+| `skilllite_run_skill` | Execute a pre-defined skill |
+| `skilllite_scan_code` | Scan code for security issues |
+| `skilllite_execute_code` | Execute code in secure sandbox |
+
+### Security Features
+
+- **System-level Sandbox**: macOS Seatbelt / Linux Namespace isolation
+- **Security Scanning**: Static analysis before execution
+- **User Confirmation**: Dangerous code requires explicit approval
+- **Scan ID Verification**: Prevents code modification between scan and execution
+
+For detailed documentation, see [OpenCode Integration Tutorial](../tutorials/07_opencode_integration/README.md).
+
+## CLI Commands
+
+```bash
+skilllite install        # Install skillbox sandbox binary
+skilllite uninstall      # Remove skillbox binary
+skilllite status         # Show installation status
+skilllite version        # Show version information
+skilllite mcp            # Start MCP server
+skilllite init-opencode  # Initialize OpenCode integration
+```
+
 ## License
 
 MIT License

skilllite-0.1.2.dist-info/RECORD

@@ -0,0 +1,45 @@
+skilllite/__init__.py,sha256=D_6otb8PNLUqpxlsp_7WtLJlX7JDziOxGBc8iQhER9Q,3984
+skilllite/analyzer.py,sha256=YG-ZJ6bO59pkP8LGECjcyCDPpH6wUYOm5QGx6et-ItA,14504
+skilllite/builtin_tools.py,sha256=MGIlMlYTfj590PCY4ngbQteDIryfH7sDoKQyrDTH6L8,8067
+skilllite/quick.py,sha256=_NWMBMywn0EK0dNeicbz37-M3UfnC7di3wjdBB0rPA4,16768
+skilllite/validation.py,sha256=K3Hn6VKT7aybdKX8GXSRaxLbKmyVAnMYmP9cqh-D4s4,4308
+skilllite/cli/__init__.py,sha256=PATRR5ZeAoB9H4gzVgw_5VAiP1GybZOuiAa1rOKFdW0,611
+skilllite/cli/__main__.py,sha256=69kpU78u45_64qSgv1v6x3m3xxaWjHwb-QdjbpxXZCo,152
+skilllite/cli/binary.py,sha256=Yp8um1G33r9SFuiAJcJ41XaMotHuNKo08bCet-0jd0g,2264
+skilllite/cli/main.py,sha256=cyLb6l7dDuvmu7ZCJhUsU9MeTzQo0qKLrnC75EKf5Sw,3983
+skilllite/cli/mcp.py,sha256=Kp-Z6aRZ7NB3T-y-b56jx6AnRyPOkfzfFQmBxYAB23Q,767
+skilllite/cli/integrations/__init__.py,sha256=-NWqUaDEPCRpykfDOvl2zfpUfLIH3UxG1qUbmTvb92o,120
+skilllite/cli/integrations/opencode.py,sha256=wT7rCqOkmX9GdhI994-0HhUtZEJ3PELPOC9PRscQDls,10521
+skilllite/core/__init__.py,sha256=N6ZEqHBnmnhtZksqVDayCZ0oPEM_rACRsGhzNm191tU,2089
+skilllite/core/executor.py,sha256=eNPcVKxKcLUjHJ7K2hstKtxobZiDIvPjk2IhbZv3nxo,6517
+skilllite/core/handler.py,sha256=wVucut7ZfDxgCa3b6A99hxq-6OycRRQaMfGyBuxNMWk,16623
+skilllite/core/loops.py,sha256=MVPMUOYgJT6VEvtAavB1PR-6kBh5kE7BlFE4ndBRgzE,39195
+skilllite/core/manager.py,sha256=t87Qyql2YZQrUTiGAbI3q-8LF5Hiuy81HUvKCzwWtyQ,22451
+skilllite/core/metadata.py,sha256=N-EOtPIRVM8sCAvvd75ogpqE3w2qIN-WKQ562mKHtPI,11607
+skilllite/core/prompt_builder.py,sha256=rsubLzien9lKjOqM6iTn5nourPnz1-QQGzljiO0Z_3I,12844
+skilllite/core/registry.py,sha256=AeljsV1uuYEJFGjpSwYxU6JGJ6EUuW8uNO3KirzHkuQ,6622
+skilllite/core/security.py,sha256=Z91v4lltHDTJsk2tM1Ezu2TwjmZiWUqKlFKDABZEv2k,14185
+skilllite/core/skill_info.py,sha256=4_jsArmn1e7jEUXDEkmDAzjSI_903sdpfNLHOp1t1-M,6079
+skilllite/core/tool_builder.py,sha256=k28ze50h7AjBiEfgKR6Y4DUFIGZJ1sCYbHEk_VkYl7w,12866
+skilllite/core/tools.py,sha256=3RiAnZ_7S7iE6ZHXTPNKmAYQFY8SBUEzcQJZA0tZmX8,8168
+skilllite/core/adapters/__init__.py,sha256=cvPkwBxRCyoNi4GWkAYwsoNuJqR-BdziLm83EEkBhio,2698
+skilllite/core/adapters/langchain.py,sha256=osacceLNv3mo5x8Oe9obzefGpH1hhxhbXqMavSKAo5Y,13169
+skilllite/core/adapters/llamaindex.py,sha256=El-oQxzniMv9rPVdH6udmzrzz_hE50rd1goVWxzib68,9037
+skilllite/mcp/__init__.py,sha256=xrpoWy9zs8IJkW6fkkR4XjQrITo5PWvFW9NkmK8E2Fg,1028
+skilllite/mcp/server.py,sha256=VsdR36dF4YR3l5IUEsE7NfXd_zppy5J6egRVs_PhfSM,47934
+skilllite/sandbox/__init__.py,sha256=6LPisVXB94SJ-C34nBAxd05NGEZR4PPxz2xaDpX4qEk,918
+skilllite/sandbox/base.py,sha256=-Ul2QufoQ3myJNzBOEdv30A2HVSR9Oe4zEqpe9oJGqY,2628
+skilllite/sandbox/config.py,sha256=eA3ceou6jF4S5kptv6cmIGKynQTaGDx3_vRrkJGQaAE,8207
+skilllite/sandbox/context.py,sha256=3C8Z3RiXJCcFI-Sx4nT9Dkf0d38BPzRTCsAbj-NODWc,5982
+skilllite/sandbox/execution_service.py,sha256=vQERxKzRk4rc50qmuPQfR9OY62bybm3KH_Q-kuzCl8s,8937
+skilllite/sandbox/unified_executor.py,sha256=4gSwTd1-EwLWSZ1dyM3eXauhyTd32vCkS6sVr6m3qYM,12229
+skilllite/sandbox/utils.py,sha256=o5AZVkhqIcZE9veUy7FTfN7uMHVWJJLYXs7gYIXsptg,2572
+skilllite/sandbox/skillbox/__init__.py,sha256=SFnNlLnnAc_NEEkqOkDbxYNfXROL7n1S09K_HFI_BOE,866
+skilllite/sandbox/skillbox/binary.py,sha256=TNKQamWucMw-J6L5BjAasNpYqhBcBpHwQPMqjUOkgp4,11838
+skilllite/sandbox/skillbox/executor.py,sha256=xobVd5JmzJnwouVOO3arvN6IuC5VH28SXPqKHCXalHM,27175
+skilllite-0.1.2.dist-info/licenses/LICENSE,sha256=ESBZ3GI5LkrbA2s5jZUQDqdcQ8oRlmk04aIYh34cOsw,1071
+skilllite-0.1.2.dist-info/METADATA,sha256=A56Fqpe_U_BY5vls_YUSxnvqvYb4lunbyQRPaB1Gguc,12706
+skilllite-0.1.2.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+skilllite-0.1.2.dist-info/entry_points.txt,sha256=H-meSKN3XzctxMvY6fa-YjAWyzs9t_0IjujOfumn4Wk,84
+skilllite-0.1.2.dist-info/top_level.txt,sha256=aqo-9FEJuBbFT7WGE3aycTj27OxyQPCN6TuZtOcClAI,10
+skilllite-0.1.2.dist-info/RECORD,,