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

skilllite/mcp/server.py

@@ -4,15 +4,22 @@ MCP Server implementation for SkillLite.
 This module provides a secure code execution sandbox server implementing
 the Model Context Protocol (MCP).
 
+Features:
+    1. **Skills Management**: List, inspect, and execute pre-defined skills
+       from the skills directory.
+
+    2. **Code Execution**: Execute arbitrary code in a secure sandbox with
+       security scanning.
+
 Security Model:
     The MCP server implements a two-phase execution model for security:
-    
+
     1. **scan_code**: First, scan the code for security issues. This returns
        a detailed report of any potential risks found in the code.
-    
+
     2. **execute_code**: Then, execute the code. If security issues were found,
        the caller must explicitly set `confirmed=true` to proceed.
-    
+
     This allows LLM clients to present security warnings to users and get
     explicit confirmation before executing potentially dangerous code.
 
@@ -20,6 +27,7 @@ Environment Variables:
     SKILLBOX_SANDBOX_LEVEL: Default sandbox level (1/2/3, default: 3)
     SKILLBOX_PATH: Path to skillbox binary
     MCP_SANDBOX_TIMEOUT: Execution timeout in seconds (default: 30)
+    SKILLLITE_SKILLS_DIR: Directory containing skills (default: ./.skills)
 """
 
 import asyncio
@@ -494,21 +502,31 @@ This skill executes code from MCP.
 class MCPServer:
     """MCP server for SkillLite sandbox execution.
     
-    This server provides two tools for secure code execution:
-    
-    1. **scan_code**: Scan code for security issues before execution.
+    This server provides tools for skills management and secure code execution:
+
+    Skills Tools:
+    1. **list_skills**: List all available skills in the skills directory.
+    2. **get_skill_info**: Get detailed information about a specific skill.
+    3. **run_skill**: Execute a skill with given input parameters.
+
+    Code Execution Tools:
+    4. **scan_code**: Scan code for security issues before execution.
        Returns a detailed report and a scan_id for confirmation.
-    
-    2. **execute_code**: Execute code in a sandbox. If high-severity
+    5. **execute_code**: Execute code in a sandbox. If high-severity
        security issues are found, requires explicit confirmation.
-    
-    Example workflow:
+
+    Example workflow for skills:
+        1. Call list_skills to see available skills
+        2. Call get_skill_info to understand a skill's parameters
+        3. Call run_skill with the required input
+
+    Example workflow for code execution:
         1. Call scan_code to check for security issues
         2. Review the security report with the user
         3. If user approves, call execute_code with confirmed=true and scan_id
     """
-    
-    def __init__(self):
+
+    def __init__(self, skills_dir: Optional[str] = None):
         if not MCP_AVAILABLE:
             raise ImportError(
                 "MCP library not available. Please install it with: "
@@ -516,14 +534,84 @@ class MCPServer:
             )
         self.server = Server("skilllite-mcp-server")
         self.executor = SandboxExecutor()
+
+        # Initialize SkillManager for skills support
+        self.skills_dir = skills_dir or os.environ.get("SKILLLITE_SKILLS_DIR", "./.skills")
+        self.skill_manager = None
+        self._init_skill_manager()
+
         self._setup_handlers()
+
+    def _init_skill_manager(self):
+        """Initialize the SkillManager if skills directory exists."""
+        try:
+            from ..core.manager import SkillManager
+            skills_path = Path(self.skills_dir)
+            if skills_path.exists():
+                self.skill_manager = SkillManager(skills_dir=str(skills_path))
+        except Exception as e:
+            # Skills not available, continue without them
+            pass
     
     def _setup_handlers(self):
         """Setup MCP server handlers."""
-        
+
         @self.server.list_tools()
         async def list_tools() -> List[Tool]:
-            return [
+            tools = [
+                # Skills management tools
+                Tool(
+                    name="list_skills",
+                    description=(
+                        "List all available skills in the skills directory. "
+                        "Returns skill names, descriptions, and languages."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {},
+                        "required": []
+                    }
+                ),
+                Tool(
+                    name="get_skill_info",
+                    description=(
+                        "Get detailed information about a specific skill, "
+                        "including its input schema, description, and usage."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "skill_name": {
+                                "type": "string",
+                                "description": "Name of the skill to get info for"
+                            }
+                        },
+                        "required": ["skill_name"]
+                    }
+                ),
+                Tool(
+                    name="run_skill",
+                    description=(
+                        "Execute a skill with the given input parameters. "
+                        "Use list_skills to see available skills and "
+                        "get_skill_info to understand required parameters."
+                    ),
+                    inputSchema={
+                        "type": "object",
+                        "properties": {
+                            "skill_name": {
+                                "type": "string",
+                                "description": "Name of the skill to execute"
+                            },
+                            "input": {
+                                "type": "object",
+                                "description": "Input parameters for the skill"
+                            }
+                        },
+                        "required": ["skill_name"]
+                    }
+                ),
+                # Code execution tools
                 Tool(
                     name="scan_code",
                     description=(
@@ -595,13 +683,22 @@ class MCPServer:
                     }
                 )
             ]
+            return tools
         
         @self.server.call_tool()
         async def call_tool(
             name: str,
             arguments: Dict[str, Any]
         ) -> "CallToolResult":
-            if name == "scan_code":
+            # Skills management tools
+            if name == "list_skills":
+                return await self._handle_list_skills(arguments)
+            elif name == "get_skill_info":
+                return await self._handle_get_skill_info(arguments)
+            elif name == "run_skill":
+                return await self._handle_run_skill(arguments)
+            # Code execution tools
+            elif name == "scan_code":
                 return await self._handle_scan_code(arguments)
             elif name == "execute_code":
                 return await self._handle_execute_code(arguments)
@@ -712,7 +809,190 @@ class MCPServer:
                     )
                 ]
             )
-    
+
+    async def _handle_list_skills(self, arguments: Dict[str, Any]) -> "CallToolResult":
+        """Handle list_skills tool call."""
+        if not self.skill_manager:
+            return CallToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"No skills available. Skills directory not found: {self.skills_dir}"
+                    )
+                ]
+            )
+
+        skills = self.skill_manager.list_skills()
+        if not skills:
+            return CallToolResult(
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"No skills found in directory: {self.skills_dir}"
+                    )
+                ]
+            )
+
+        # Format skills list
+        lines = ["Available Skills:", ""]
+        for skill in skills:
+            lines.append(f"• **{skill.name}**")
+            if skill.description:
+                lines.append(f"  {skill.description}")
+            if skill.language:
+                lines.append(f"  Language: {skill.language}")
+            lines.append("")
+
+        return CallToolResult(
+            content=[
+                TextContent(
+                    type="text",
+                    text="\n".join(lines)
+                )
+            ]
+        )
+
+    async def _handle_get_skill_info(self, arguments: Dict[str, Any]) -> "CallToolResult":
+        """Handle get_skill_info tool call."""
+        skill_name = arguments.get("skill_name")
+
+        if not skill_name:
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text="Missing required argument: skill_name"
+                    )
+                ]
+            )
+
+        if not self.skill_manager:
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"No skills available. Skills directory not found: {self.skills_dir}"
+                    )
+                ]
+            )
+
+        skill = self.skill_manager.get_skill(skill_name)
+        if not skill:
+            available = ", ".join(self.skill_manager.skill_names()) or "none"
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Skill not found: {skill_name}\nAvailable skills: {available}"
+                    )
+                ]
+            )
+
+        # Format skill info
+        lines = [f"# {skill.name}", ""]
+        if skill.description:
+            lines.append(skill.description)
+            lines.append("")
+
+        lines.append("## Details")
+        lines.append(f"- **Language**: {skill.language or 'unknown'}")
+        lines.append(f"- **Path**: {skill.path}")
+        if skill.entry_point:
+            lines.append(f"- **Entry Point**: {skill.entry_point}")
+
+        # Add input schema if available
+        if skill.input_schema:
+            lines.append("")
+            lines.append("## Input Schema")
+            lines.append("```json")
+            lines.append(json.dumps(skill.input_schema, indent=2))
+            lines.append("```")
+
+        return CallToolResult(
+            content=[
+                TextContent(
+                    type="text",
+                    text="\n".join(lines)
+                )
+            ]
+        )
+
+    async def _handle_run_skill(self, arguments: Dict[str, Any]) -> "CallToolResult":
+        """Handle run_skill tool call."""
+        skill_name = arguments.get("skill_name")
+        input_data = arguments.get("input", {})
+
+        if not skill_name:
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text="Missing required argument: skill_name"
+                    )
+                ]
+            )
+
+        if not self.skill_manager:
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"No skills available. Skills directory not found: {self.skills_dir}"
+                    )
+                ]
+            )
+
+        if not self.skill_manager.has_skill(skill_name):
+            available = ", ".join(self.skill_manager.skill_names()) or "none"
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Skill not found: {skill_name}\nAvailable skills: {available}"
+                    )
+                ]
+            )
+
+        # Execute the skill
+        try:
+            result = self.skill_manager.execute(skill_name, input_data)
+
+            if result.success:
+                return CallToolResult(
+                    content=[
+                        TextContent(
+                            type="text",
+                            text=f"Skill '{skill_name}' executed successfully.\n\nOutput:\n{result.output}"
+                        )
+                    ]
+                )
+            else:
+                return CallToolResult(
+                    isError=True,
+                    content=[
+                        TextContent(
+                            type="text",
+                            text=f"Skill '{skill_name}' execution failed.\n\nError:\n{result.error}"
+                        )
+                    ]
+                )
+        except Exception as e:
+            return CallToolResult(
+                isError=True,
+                content=[
+                    TextContent(
+                        type="text",
+                        text=f"Error executing skill '{skill_name}': {str(e)}"
+                    )
+                ]
+            )
+
     async def run(self):
         """Run the MCP server."""
         async with stdio_server() as (read_stream, write_stream):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skilllite
-Version: 0.1.0
+Version: 0.1.1
 Summary: A lightweight Skills execution engine with LLM integration for LLM agents
 Author-email: SkillLite Team <skilllite@example.com>
 License: MIT
@@ -288,6 +288,59 @@ Enum for LLM provider formats:
 - `ToolFormat.CLAUDE`
 - `ToolFormat.OPENAI`
 
+## 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.0.dist-info → skilllite-0.1.1.dist-info}/RECORD

@@ -1,13 +1,19 @@
-skilllite/__init__.py,sha256=Ws0SEhXeqPTme-ASatdgkIba49zhZItN1Xlh2TVdhDY,3984
+skilllite/__init__.py,sha256=D_6otb8PNLUqpxlsp_7WtLJlX7JDziOxGBc8iQhER9Q,3984
 skilllite/analyzer.py,sha256=YG-ZJ6bO59pkP8LGECjcyCDPpH6wUYOm5QGx6et-ItA,14504
 skilllite/builtin_tools.py,sha256=MGIlMlYTfj590PCY4ngbQteDIryfH7sDoKQyrDTH6L8,8067
-skilllite/cli.py,sha256=Ns_wjCWz3Lh67P6QB7HYe2gM94FG8mEwKvPnQIx9uqI,6209
 skilllite/quick.py,sha256=TNqKaww92WHUMf9nkjMZkdVjzz222lOKyjCwNp90_9c,16132
 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=nU9yWE_M7xuWaIa1Ks_0dPfilRpW9GhlKfTV6eEU7-U,2044
 skilllite/core/executor.py,sha256=eNPcVKxKcLUjHJ7K2hstKtxobZiDIvPjk2IhbZv3nxo,6517
 skilllite/core/handler.py,sha256=pbQo5Gv-YSecufqpVbC0y8KP7Ra4uxxYpOW1nBimn5g,10354
-skilllite/core/loops.py,sha256=2LEIyhYbHAR5YqvkyQeoRLYJPbKoEPaBK_wSMo47wKI,32210
+skilllite/core/loops.py,sha256=SQEhQolo2_yD3Vk5NAZ_3D1OPX0zpQ2N3SIIfay6Gao,32325
 skilllite/core/manager.py,sha256=uYAO5JtHM4DQvPnybBChHe0hUdOse1yBiQyc7vZ4nB8,19798
 skilllite/core/metadata.py,sha256=mdZdK-qfK7wSaZrAAn2U25k0I63NrYuibtBHIrYR5RA,11221
 skilllite/core/prompt_builder.py,sha256=rsubLzien9lKjOqM6iTn5nourPnz1-QQGzljiO0Z_3I,12844
@@ -16,7 +22,7 @@ skilllite/core/skill_info.py,sha256=4_jsArmn1e7jEUXDEkmDAzjSI_903sdpfNLHOp1t1-M,
 skilllite/core/tool_builder.py,sha256=k28ze50h7AjBiEfgKR6Y4DUFIGZJ1sCYbHEk_VkYl7w,12866
 skilllite/core/tools.py,sha256=3RiAnZ_7S7iE6ZHXTPNKmAYQFY8SBUEzcQJZA0tZmX8,8168
 skilllite/mcp/__init__.py,sha256=xrpoWy9zs8IJkW6fkkR4XjQrITo5PWvFW9NkmK8E2Fg,1028
-skilllite/mcp/server.py,sha256=vhM0Kgjul1DZ5XFFKjuWZ0iksFP4nWl9n_bpiaakpTM,27912
+skilllite/mcp/server.py,sha256=3s7pYHZY3785QS120C1O6cF1RnVfrteEkhAGbJwDMHw,38091
 skilllite/sandbox/__init__.py,sha256=6LPisVXB94SJ-C34nBAxd05NGEZR4PPxz2xaDpX4qEk,918
 skilllite/sandbox/base.py,sha256=-Ul2QufoQ3myJNzBOEdv30A2HVSR9Oe4zEqpe9oJGqY,2628
 skilllite/sandbox/config.py,sha256=eA3ceou6jF4S5kptv6cmIGKynQTaGDx3_vRrkJGQaAE,8207
@@ -24,9 +30,9 @@ skilllite/sandbox/utils.py,sha256=o5AZVkhqIcZE9veUy7FTfN7uMHVWJJLYXs7gYIXsptg,25
 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=dXCR8JMwjD-x7-LfOCQbvgSq-29ZLIkXLp4oHed7b1Y,22872
-skilllite-0.1.0.dist-info/licenses/LICENSE,sha256=ESBZ3GI5LkrbA2s5jZUQDqdcQ8oRlmk04aIYh34cOsw,1071
-skilllite-0.1.0.dist-info/METADATA,sha256=-uHBXQuqfXHjGqsf5Qc5MELgUe9Lq_0UPUwpTFsyeTQ,8190
-skilllite-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-skilllite-0.1.0.dist-info/entry_points.txt,sha256=H-meSKN3XzctxMvY6fa-YjAWyzs9t_0IjujOfumn4Wk,84
-skilllite-0.1.0.dist-info/top_level.txt,sha256=aqo-9FEJuBbFT7WGE3aycTj27OxyQPCN6TuZtOcClAI,10
-skilllite-0.1.0.dist-info/RECORD,,
+skilllite-0.1.1.dist-info/licenses/LICENSE,sha256=ESBZ3GI5LkrbA2s5jZUQDqdcQ8oRlmk04aIYh34cOsw,1071
+skilllite-0.1.1.dist-info/METADATA,sha256=EaYy1mJx-5zAmdE8ZlFbn4cbhKNKV0QG2tBclCu9BV0,9984
+skilllite-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+skilllite-0.1.1.dist-info/entry_points.txt,sha256=H-meSKN3XzctxMvY6fa-YjAWyzs9t_0IjujOfumn4Wk,84
+skilllite-0.1.1.dist-info/top_level.txt,sha256=aqo-9FEJuBbFT7WGE3aycTj27OxyQPCN6TuZtOcClAI,10
+skilllite-0.1.1.dist-info/RECORD,,