skilllite 0.1.1__tar.gz → 0.1.2__tar.gz

{skilllite-0.1.1/skilllite.egg-info → skilllite-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: skilllite
-Version: 0.1.1
+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,97 @@ 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.

{skilllite-0.1.1 → skilllite-0.1.2}/README.md

@@ -242,6 +242,97 @@ 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.

{skilllite-0.1.1 → skilllite-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skilllite"
-version = "0.1.1"
+version = "0.1.2"
 description = "A lightweight Skills execution engine with LLM integration for LLM agents"
 readme = "README.md"
 license = {text = "MIT"}
@@ -36,10 +36,14 @@ dependencies = [
 openai = ["openai>=1.0.0"]
 anthropic = ["anthropic>=0.18.0"]
 mcp = ["mcp>=1.0.0"]
+langchain = ["langchain-core>=0.1.0"]
+llamaindex = ["llama-index-core>=0.10.0"]
 all = [
     "openai>=1.0.0",
     "anthropic>=0.18.0",
     "mcp>=1.0.0",
+    "langchain-core>=0.1.0",
+    "llama-index-core>=0.10.0",
 ]
 dev = [
     "pytest>=7.0",

{skilllite-0.1.1 → skilllite-0.1.2}/skilllite/core/__init__.py

@@ -62,4 +62,6 @@ __all__ = [
     "ToolFormat",
     # Utilities
     "parse_skill_metadata",
+    # Adapters (lazy loaded)
+    "adapters",
 ]

skilllite-0.1.2/skilllite/core/adapters/__init__.py

@@ -0,0 +1,74 @@
+"""
+SkillLite Adapters - Framework adapters for LangChain, LlamaIndex, etc.
+
+This module provides adapters for integrating SkillLite with popular AI frameworks:
+- LangChain: SkillLiteTool, SkillLiteToolkit
+- LlamaIndex: SkillLiteToolSpec
+
+Both adapters support sandbox security confirmation (sandbox_level=3):
+- SecurityScanResult: Contains scan results with severity counts
+- ConfirmationCallback: Type alias for (report: str, scan_id: str) -> bool
+
+Usage:
+    # LangChain (requires: pip install skilllite[langchain])
+    from skilllite.core.adapters.langchain import SkillLiteTool, SkillLiteToolkit
+
+    # LlamaIndex (requires: pip install skilllite[llamaindex])
+    from skilllite.core.adapters.llamaindex import SkillLiteToolSpec
+
+    # Security confirmation callback
+    def confirm(report: str, scan_id: str) -> bool:
+        print(report)
+        return input("Continue? [y/N]: ").lower() == 'y'
+
+    toolkit = SkillLiteToolkit.from_manager(
+        manager, sandbox_level=3, confirmation_callback=confirm
+    )
+"""
+
+__all__ = [
+    "SkillLiteTool",
+    "SkillLiteToolkit",
+    "SkillLiteToolSpec",
+    "SecurityScanResult",
+    "ConfirmationCallback",
+    "AsyncConfirmationCallback",
+]
+
+
+def __getattr__(name: str):
+    """Lazy import to avoid requiring all dependencies at import time."""
+    if name in ("SkillLiteTool", "SkillLiteToolkit", "SecurityScanResult",
+                "ConfirmationCallback", "AsyncConfirmationCallback"):
+        try:
+            from .langchain import (
+                SkillLiteTool, SkillLiteToolkit, SecurityScanResult,
+                ConfirmationCallback, AsyncConfirmationCallback
+            )
+            return {
+                "SkillLiteTool": SkillLiteTool,
+                "SkillLiteToolkit": SkillLiteToolkit,
+                "SecurityScanResult": SecurityScanResult,
+                "ConfirmationCallback": ConfirmationCallback,
+                "AsyncConfirmationCallback": AsyncConfirmationCallback,
+            }[name]
+        except ImportError as e:
+            raise ImportError(
+                f"LangChain adapter requires langchain. "
+                f"Install with: pip install skilllite[langchain]\n"
+                f"Original error: {e}"
+            ) from e
+
+    if name == "SkillLiteToolSpec":
+        try:
+            from .llamaindex import SkillLiteToolSpec
+            return SkillLiteToolSpec
+        except ImportError as e:
+            raise ImportError(
+                f"LlamaIndex adapter requires llama-index. "
+                f"Install with: pip install skilllite[llamaindex]\n"
+                f"Original error: {e}"
+            ) from e
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+

skilllite-0.1.2/skilllite/core/adapters/langchain.py

@@ -0,0 +1,362 @@
+"""
+LangChain adapter for SkillLite.
+
+Provides SkillLiteTool and SkillLiteToolkit for integrating SkillLite
+skills into LangChain agents.
+
+Usage:
+    from skilllite import SkillManager
+    from skilllite.core.adapters.langchain import SkillLiteToolkit
+
+    manager = SkillManager(skills_dir="./skills")
+    tools = SkillLiteToolkit.from_manager(manager)
+
+    # Use with LangChain agent
+    from langchain.agents import create_openai_tools_agent, AgentExecutor
+    agent = create_openai_tools_agent(llm, tools, prompt)
+    executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools)
+
+Security Confirmation:
+    For sandbox level 3, the adapter supports security confirmation callbacks:
+
+    def my_confirmation_callback(security_report: str, scan_id: str) -> bool:
+        print(security_report)
+        return input("Continue? [y/N]: ").lower() == 'y'
+
+    tools = SkillLiteToolkit.from_manager(
+        manager,
+        sandbox_level=3,
+        confirmation_callback=my_confirmation_callback
+    )
+
+Requirements:
+    pip install skilllite[langchain]
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Type, TYPE_CHECKING
+import asyncio
+import time
+
+try:
+    from langchain_core.tools import BaseTool
+    from langchain_core.callbacks import CallbackManagerForToolRun, AsyncCallbackManagerForToolRun
+    from pydantic import BaseModel, Field, ConfigDict
+except ImportError as e:
+    raise ImportError(
+        "LangChain adapter requires langchain-core. "
+        "Install with: pip install skilllite[langchain]"
+    ) from e
+
+if TYPE_CHECKING:
+    from ..manager import SkillManager
+
+
+# Type alias for confirmation callback
+# Signature: (security_report: str, scan_id: str) -> bool
+ConfirmationCallback = Callable[[str, str], bool]
+AsyncConfirmationCallback = Callable[[str, str], "asyncio.Future[bool]"]
+
+
+@dataclass
+class SecurityScanResult:
+    """Result of a security scan for LangChain adapter."""
+
+    is_safe: bool
+    issues: List[Dict[str, Any]] = field(default_factory=list)
+    scan_id: str = ""
+    code_hash: str = ""
+    high_severity_count: int = 0
+    medium_severity_count: int = 0
+    low_severity_count: int = 0
+    timestamp: float = field(default_factory=time.time)
+
+    @property
+    def requires_confirmation(self) -> bool:
+        """Check if user confirmation is required."""
+        return self.high_severity_count > 0
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "is_safe": self.is_safe,
+            "issues": self.issues,
+            "scan_id": self.scan_id,
+            "code_hash": self.code_hash,
+            "high_severity_count": self.high_severity_count,
+            "medium_severity_count": self.medium_severity_count,
+            "low_severity_count": self.low_severity_count,
+            "requires_confirmation": self.requires_confirmation,
+        }
+
+    def format_report(self) -> str:
+        """Format a human-readable security report."""
+        if not self.issues:
+            return "✅ Security scan passed. No issues found."
+
+        lines = [
+            f"📋 Security Scan Report (ID: {self.scan_id[:8]})",
+            f"   Found {len(self.issues)} item(s) for review:",
+            "",
+        ]
+
+        severity_icons = {
+            "Critical": "🔴",
+            "High": "🟠",
+            "Medium": "🟡",
+            "Low": "🟢",
+        }
+
+        for idx, issue in enumerate(self.issues, 1):
+            severity = issue.get("severity", "Medium")
+            icon = severity_icons.get(severity, "⚪")
+            lines.append(f"  {icon} #{idx} [{severity}] {issue.get('issue_type', 'Unknown')}")
+            lines.append(f"     ├─ Rule: {issue.get('rule_id', 'N/A')}")
+            lines.append(f"     ├─ Line {issue.get('line_number', '?')}: {issue.get('description', '')}")
+            snippet = issue.get('code_snippet', '')
+            lines.append(f"     └─ Code: {snippet[:60]}{'...' if len(snippet) > 60 else ''}")
+            lines.append("")
+
+        if self.high_severity_count > 0:
+            lines.append("⚠️  High severity issues found. Confirmation required to execute.")
+        else:
+            lines.append("ℹ️  Only low/medium severity issues found. Safe to execute.")
+
+        return "\n".join(lines)
+
+
+class SkillLiteTool(BaseTool):
+    """
+    LangChain BaseTool adapter for a single SkillLite skill.
+
+    This wraps a SkillLite skill as a LangChain tool, enabling it to be
+    used with LangChain agents.
+
+    Attributes:
+        name: Tool name (same as skill name)
+        description: Tool description
+        manager: SkillManager instance
+        skill_name: Name of the skill to execute
+        allow_network: Whether to allow network access
+        timeout: Execution timeout in seconds
+        sandbox_level: Sandbox security level (1/2/3, default: 3)
+        confirmation_callback: Callback for security confirmation (sync)
+        async_confirmation_callback: Callback for security confirmation (async)
+    """
+
+    name: str = Field(description="Tool name")
+    description: str = Field(description="Tool description")
+    args_schema: Optional[Type[BaseModel]] = Field(default=None, description="Pydantic schema for arguments")
+
+    # SkillLite specific fields
+    manager: Any = Field(exclude=True)  # SkillManager instance
+    skill_name: str = Field(description="SkillLite skill name")
+    allow_network: bool = Field(default=False, description="Allow network access")
+    timeout: Optional[int] = Field(default=None, description="Execution timeout in seconds")
+
+    # Security confirmation fields
+    sandbox_level: int = Field(default=3, description="Sandbox security level (1/2/3)")
+    confirmation_callback: Optional[Any] = Field(
+        default=None,
+        exclude=True,
+        description="Sync callback for security confirmation: (report: str, scan_id: str) -> bool"
+    )
+    async_confirmation_callback: Optional[Any] = Field(
+        default=None,
+        exclude=True,
+        description="Async callback for security confirmation: (report: str, scan_id: str) -> Future[bool]"
+    )
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+        **kwargs: Any
+    ) -> str:
+        """
+        Execute the skill synchronously using UnifiedExecutionService.
+
+        This method uses the unified execution layer which:
+        1. Reads sandbox level at runtime
+        2. Handles security scanning and confirmation
+        3. Properly downgrades sandbox level after confirmation
+        """
+        try:
+            # Get skill info
+            skill_info = self.manager._registry.get_skill(self.skill_name)
+            if not skill_info:
+                return f"Error: Skill '{self.skill_name}' not found"
+
+            # Use UnifiedExecutionService
+            from ...sandbox.execution_service import UnifiedExecutionService
+
+            service = UnifiedExecutionService.get_instance()
+            result = service.execute_skill(
+                skill_info=skill_info,
+                input_data=kwargs,
+                confirmation_callback=self.confirmation_callback,
+                allow_network=self.allow_network,
+                timeout=self.timeout,
+            )
+
+            if result.success:
+                return result.output or "Execution completed successfully"
+            else:
+                return f"Error: {result.error}"
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+
+    async def _arun(
+        self,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+        **kwargs: Any
+    ) -> str:
+        """
+        Execute the skill asynchronously using UnifiedExecutionService.
+
+        This method uses the unified execution layer which:
+        1. Reads sandbox level at runtime
+        2. Handles security scanning and confirmation
+        3. Properly downgrades sandbox level after confirmation
+        """
+        try:
+            # Get skill info
+            skill_info = self.manager._registry.get_skill(self.skill_name)
+            if not skill_info:
+                return f"Error: Skill '{self.skill_name}' not found"
+
+            # Use UnifiedExecutionService in thread pool
+            from ...sandbox.execution_service import UnifiedExecutionService
+
+            def execute_sync():
+                service = UnifiedExecutionService.get_instance()
+                # Use async confirmation callback if available, otherwise sync
+                callback = self.confirmation_callback
+                return service.execute_skill(
+                    skill_info=skill_info,
+                    input_data=kwargs,
+                    confirmation_callback=callback,
+                    allow_network=self.allow_network,
+                    timeout=self.timeout,
+                )
+
+            result = await asyncio.to_thread(execute_sync)
+
+            if result.success:
+                return result.output or "Execution completed successfully"
+            else:
+                return f"Error: {result.error}"
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+
+
+class SkillLiteToolkit:
+    """
+    LangChain Toolkit for SkillLite.
+
+    Provides a convenient way to create LangChain tools from all skills
+    registered in a SkillManager.
+
+    Usage:
+        manager = SkillManager(skills_dir="./skills")
+        tools = SkillLiteToolkit.from_manager(manager)
+
+        # Or with options
+        tools = SkillLiteToolkit.from_manager(
+            manager,
+            skill_names=["calculator", "web_search"],  # Only specific skills
+            allow_network=True,
+            timeout=60
+        )
+
+        # With security confirmation callback (for sandbox level 3)
+        def confirm_execution(report: str, scan_id: str) -> bool:
+            print(report)
+            return input("Continue? [y/N]: ").lower() == 'y'
+
+        tools = SkillLiteToolkit.from_manager(
+            manager,
+            sandbox_level=3,
+            confirmation_callback=confirm_execution
+        )
+    """
+
+    @staticmethod
+    def from_manager(
+        manager: "SkillManager",
+        skill_names: Optional[List[str]] = None,
+        allow_network: bool = False,
+        timeout: Optional[int] = None,
+        sandbox_level: int = 3,
+        confirmation_callback: Optional[ConfirmationCallback] = None,
+        async_confirmation_callback: Optional[AsyncConfirmationCallback] = None,
+    ) -> List[SkillLiteTool]:
+        """
+        Create LangChain tools from a SkillManager.
+
+        Args:
+            manager: SkillManager instance with registered skills
+            skill_names: Optional list of skill names to include (default: all)
+            allow_network: Whether to allow network access for all tools
+            timeout: Execution timeout in seconds for all tools
+            sandbox_level: Sandbox security level (1/2/3, default: 3)
+                - Level 1: No sandbox - direct execution
+                - Level 2: Sandbox isolation only
+                - Level 3: Sandbox isolation + security scanning (requires confirmation for high-severity issues)
+            confirmation_callback: Sync callback for security confirmation.
+                Signature: (security_report: str, scan_id: str) -> bool
+                Return True to proceed, False to cancel.
+            async_confirmation_callback: Async callback for security confirmation.
+                Signature: (security_report: str, scan_id: str) -> Future[bool]
+                Return True to proceed, False to cancel.
+
+        Returns:
+            List of SkillLiteTool instances
+
+        Example with confirmation callback:
+            def my_callback(report: str, scan_id: str) -> bool:
+                print(f"Security Report:\\n{report}")
+                response = input("Proceed with execution? [y/N]: ")
+                return response.lower() == 'y'
+
+            tools = SkillLiteToolkit.from_manager(
+                manager,
+                sandbox_level=3,
+                confirmation_callback=my_callback
+            )
+        """
+        tools = []
+
+        # Get executable skills
+        skills = manager.list_executable_skills()
+
+        for skill in skills:
+            # Filter by name if specified
+            if skill_names and skill.name not in skill_names:
+                continue
+
+            # Create tool with security confirmation support
+            tool = SkillLiteTool(
+                name=skill.name,
+                description=skill.description or f"Execute the {skill.name} skill",
+                manager=manager,
+                skill_name=skill.name,
+                allow_network=allow_network,
+                timeout=timeout,
+                sandbox_level=sandbox_level,
+                confirmation_callback=confirmation_callback,
+                async_confirmation_callback=async_confirmation_callback,
+            )
+            tools.append(tool)
+
+        return tools
+
+
+__all__ = [
+    "SkillLiteTool",
+    "SkillLiteToolkit",
+    "SecurityScanResult",
+    "ConfirmationCallback",
+    "AsyncConfirmationCallback",
+]
+