gobby 0.2.8__py3-none-any.whl → 0.2.11__py3-none-any.whl

gobby/skills/hubs/manager.py

@@ -0,0 +1,263 @@
+"""Hub manager for coordinating skill hub providers.
+
+This module provides the HubManager class which manages hub configurations,
+creates and caches provider instances, and coordinates operations across
+multiple skill hubs.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any
+
+from gobby.skills.hubs.base import HubProvider
+
+if TYPE_CHECKING:
+    from gobby.config.skills import HubConfig
+    from gobby.llm.service import LLMService
+
+logger = logging.getLogger(__name__)
+
+# Type alias for provider factory functions
+ProviderFactory = type[HubProvider]
+
+
+class HubManager:
+    """Manages skill hub providers and configurations.
+
+    The HubManager is responsible for:
+    - Storing hub configurations
+    - Creating and caching provider instances
+    - Resolving API keys for authenticated hubs
+    - Providing a unified interface for hub operations
+
+    Example usage:
+        ```python
+        configs = {
+            "clawdhub": HubConfig(type="clawdhub", base_url="https://clawdhub.com"),
+            "skillhub": HubConfig(type="skillhub", auth_key_name="SKILLHUB_KEY"),
+        }
+        api_keys = {"SKILLHUB_KEY": "secret123"}
+
+        manager = HubManager(configs=configs, api_keys=api_keys)
+
+        # List available hubs
+        for hub_name in manager.list_hubs():
+            print(hub_name)
+
+        # Get a provider
+        provider = manager.get_provider("clawdhub")
+        results = await provider.search("commit message")
+        ```
+    """
+
+    def __init__(
+        self,
+        configs: dict[str, HubConfig] | None = None,
+        api_keys: dict[str, str] | None = None,
+        llm_service: LLMService | None = None,
+    ) -> None:
+        """Initialize the hub manager.
+
+        Args:
+            configs: Dictionary of hub configurations keyed by hub name
+            api_keys: Dictionary of API keys keyed by key name
+            llm_service: Optional LLM service for providers that need it
+        """
+        self._configs: dict[str, HubConfig] = configs or {}
+        self._api_keys: dict[str, str] = api_keys or {}
+        self._llm_service = llm_service
+        self._providers: dict[str, HubProvider] = {}
+        self._factories: dict[str, ProviderFactory] = {}
+
+    def register_provider_factory(
+        self,
+        hub_type: str,
+        factory: ProviderFactory,
+    ) -> None:
+        """Register a provider factory for a hub type.
+
+        Args:
+            hub_type: The hub type identifier (e.g., 'clawdhub', 'skillhub')
+            factory: The provider class to instantiate for this type
+        """
+        self._factories[hub_type] = factory
+        logger.debug(f"Registered provider factory for hub type: {hub_type}")
+
+    def list_hubs(self) -> list[str]:
+        """List all configured hub names.
+
+        Returns:
+            List of hub names
+        """
+        return list(self._configs.keys())
+
+    def has_hub(self, hub_name: str) -> bool:
+        """Check if a hub is configured.
+
+        Args:
+            hub_name: Name of the hub to check
+
+        Returns:
+            True if the hub exists, False otherwise
+        """
+        return hub_name in self._configs
+
+    def get_config(self, hub_name: str) -> HubConfig:
+        """Get the configuration for a hub.
+
+        Args:
+            hub_name: Name of the hub
+
+        Returns:
+            The hub configuration
+
+        Raises:
+            KeyError: If hub is not configured
+        """
+        if hub_name not in self._configs:
+            raise KeyError(f"Unknown hub: {hub_name}")
+        return self._configs[hub_name]
+
+    def _create_provider(self, hub_name: str) -> HubProvider:
+        """Create a provider instance for a hub.
+
+        This is the factory method that instantiates the correct provider
+        type based on the hub's configuration. It resolves auth tokens
+        and passes all necessary configuration to the provider.
+
+        Args:
+            hub_name: Name of the hub
+
+        Returns:
+            A new provider instance (not cached)
+
+        Raises:
+            KeyError: If hub is not configured
+            ValueError: If no factory is registered for the hub type
+        """
+        if hub_name not in self._configs:
+            raise KeyError(f"Unknown hub: {hub_name}")
+
+        config = self._configs[hub_name]
+        factory = self._factories.get(config.type)
+
+        if factory is None:
+            raise ValueError(f"No provider factory registered for hub type: {config.type}")
+
+        # Resolve auth token from api_keys if auth_key_name is set
+        auth_token: str | None = None
+        if config.auth_key_name:
+            auth_token = self._api_keys.get(config.auth_key_name)
+            if auth_token is None:
+                logger.warning(
+                    f"Auth key '{config.auth_key_name}' not found in api_keys for hub '{hub_name}'"
+                )
+
+        # Determine base_url - use config value or derive from hub type
+        base_url = config.base_url or ""
+
+        # Build provider kwargs based on hub type
+        kwargs: dict[str, Any] = {
+            "hub_name": hub_name,
+            "base_url": base_url,
+            "auth_token": auth_token,
+        }
+
+        # Add type-specific config
+        if config.type == "github-collection":
+            kwargs["repo"] = config.repo
+            kwargs["branch"] = config.branch or "main"
+            kwargs["path"] = config.path
+            kwargs["llm_service"] = self._llm_service
+
+        # Create the provider
+        provider = factory(**kwargs)
+        logger.debug(f"Created provider for hub: {hub_name} (type: {config.type})")
+
+        return provider
+
+    def get_provider(self, hub_name: str) -> HubProvider:
+        """Get or create a provider for a hub.
+
+        Providers are cached after creation, so subsequent calls
+        return the same instance.
+
+        Args:
+            hub_name: Name of the hub
+
+        Returns:
+            The provider instance for this hub
+
+        Raises:
+            KeyError: If hub is not configured
+            ValueError: If no factory is registered for the hub type
+        """
+        if hub_name not in self._configs:
+            raise KeyError(f"Unknown hub: {hub_name}")
+
+        # Return cached provider if available
+        if hub_name in self._providers:
+            return self._providers[hub_name]
+
+        # Create and cache the provider
+        provider = self._create_provider(hub_name)
+        self._providers[hub_name] = provider
+
+        return provider
+
+    async def search_all(
+        self,
+        query: str,
+        limit: int = 20,
+        hub_names: list[str] | None = None,
+    ) -> list[dict[str, Any]]:
+        """Search across multiple hubs in parallel.
+
+        Uses asyncio.gather for concurrent searches across all providers,
+        improving performance when searching multiple hubs.
+
+        Args:
+            query: Search query string
+            limit: Maximum results per hub
+            hub_names: Specific hubs to search (None for all)
+
+        Returns:
+            Combined list of results from all hubs
+        """
+        hubs_to_search = hub_names or self.list_hubs()
+
+        # Filter to valid hubs only
+        valid_hubs = []
+        for hub_name in hubs_to_search:
+            if not self.has_hub(hub_name):
+                logger.warning(f"Skipping unknown hub: {hub_name}")
+            else:
+                valid_hubs.append(hub_name)
+
+        if not valid_hubs:
+            return []
+
+        async def search_hub(hub_name: str) -> list[dict[str, Any]]:
+            """Search a single hub and return results as dicts."""
+            try:
+                provider = self.get_provider(hub_name)
+                hub_results = await provider.search(query, limit=limit)
+                return [r.to_dict() for r in hub_results]
+            except Exception as e:
+                logger.error(f"Error searching hub {hub_name}: {e}")
+                return []
+
+        # Execute all searches in parallel
+        all_results = await asyncio.gather(
+            *[search_hub(hub_name) for hub_name in valid_hubs],
+            return_exceptions=False,
+        )
+
+        # Flatten results from all hubs
+        results: list[dict[str, Any]] = []
+        for hub_results in all_results:
+            results.extend(hub_results)
+
+        return results

gobby/skills/hubs/skillhub.py

@@ -0,0 +1,342 @@
+"""SkillHub provider implementation.
+
+This module provides the SkillHubProvider class which connects to the
+SkillHub REST API for skill search, listing, and download functionality.
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+import zipfile
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+import httpx
+
+from gobby.skills.hubs.base import DownloadResult, HubProvider, HubSkillDetails, HubSkillInfo
+
+logger = logging.getLogger(__name__)
+
+
+class SkillHubProvider(HubProvider):
+    """Provider for SkillHub skill registry using REST API.
+
+    This provider connects to the SkillHub API to provide access to
+    skills in the SkillHub registry.
+
+    Authentication is via Bearer token in the Authorization header.
+
+    Example usage:
+        ```python
+        provider = SkillHubProvider(
+            hub_name="skillhub",
+            base_url="https://skillhub.dev",
+            auth_token="sk-your-api-key",
+        )
+
+        results = await provider.search("commit message")
+        for skill in results:
+            print(f"{skill.slug}: {skill.description}")
+        ```
+    """
+
+    def __init__(
+        self,
+        hub_name: str,
+        base_url: str,
+        auth_token: str | None = None,
+    ) -> None:
+        """Initialize the SkillHub provider.
+
+        Args:
+            hub_name: The configured name for this hub instance
+            base_url: Base URL for the SkillHub API
+            auth_token: Optional API key for authentication
+        """
+        super().__init__(hub_name=hub_name, base_url=base_url, auth_token=auth_token)
+
+    @property
+    def provider_type(self) -> str:
+        """Return the provider type identifier."""
+        return "skillhub"
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get HTTP headers for API requests.
+
+        Returns:
+            Dictionary of headers including Authorization if auth_token is set
+        """
+        headers: dict[str, str] = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+
+        return headers
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: dict[str, Any] | None = None,
+        json_data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """Make an HTTP request to the SkillHub API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint path
+            params: Query parameters
+            json_data: JSON body data for POST requests
+
+        Returns:
+            Parsed JSON response
+
+        Raises:
+            RuntimeError: If the request fails
+        """
+        url = f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.request(
+                    method=method,
+                    url=url,
+                    headers=self._get_headers(),
+                    params=params,
+                    json=json_data,
+                    timeout=30.0,
+                )
+                response.raise_for_status()
+                result: dict[str, Any] = response.json()
+                return result
+            except httpx.HTTPStatusError as e:
+                logger.error(f"SkillHub API error: {e.response.status_code}")
+                raise RuntimeError(f"SkillHub API error: {e.response.status_code}") from e
+            except httpx.RequestError as e:
+                logger.error(f"SkillHub request failed: {e}")
+                raise RuntimeError(f"SkillHub request failed: {e}") from e
+
+    async def _download_and_extract(
+        self,
+        download_url: str,
+        target_dir: str | None = None,
+    ) -> str:
+        """Download and extract a skill from a URL.
+
+        Downloads a ZIP file from the given URL and extracts it safely,
+        preventing path traversal attacks.
+
+        Args:
+            download_url: URL to download the skill ZIP from
+            target_dir: Optional target directory to extract to
+
+        Returns:
+            Path to the extracted skill directory
+
+        Raises:
+            RuntimeError: If download or extraction fails
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    download_url,
+                    headers=self._get_headers(),
+                    timeout=60.0,
+                    follow_redirects=True,
+                )
+                response.raise_for_status()
+                zip_content = response.content
+
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Failed to download skill: {e.response.status_code}")
+            raise RuntimeError(f"Failed to download skill: {e.response.status_code}") from e
+        except httpx.RequestError as e:
+            logger.error(f"Download request failed: {e}")
+            raise RuntimeError(f"Download request failed: {e}") from e
+
+        # Determine extraction directory
+        if target_dir:
+            extract_path = Path(target_dir)
+            extract_path.mkdir(parents=True, exist_ok=True)
+        else:
+            extract_path = Path(tempfile.mkdtemp(prefix="skillhub_"))
+
+        # Extract ZIP safely
+        try:
+            zip_buffer = BytesIO(zip_content)
+            with zipfile.ZipFile(zip_buffer, "r") as zf:
+                # Check for path traversal attacks
+                for member in zf.namelist():
+                    member_path = Path(member)
+                    # Reject absolute paths or paths with ..
+                    if member_path.is_absolute() or ".." in member_path.parts:
+                        raise RuntimeError(f"Unsafe path in ZIP: {member}")
+
+                # Extract all files
+                zf.extractall(extract_path)
+
+        except zipfile.BadZipFile as e:
+            logger.error(f"Invalid ZIP file: {e}")
+            raise RuntimeError(f"Invalid ZIP file: {e}") from e
+
+        return str(extract_path)
+
+    async def discover(self) -> dict[str, Any]:
+        """Discover hub capabilities.
+
+        Returns:
+            Dictionary with hub info
+        """
+        return {
+            "hub_name": self.hub_name,
+            "provider_type": self.provider_type,
+            "base_url": self.base_url,
+            "authenticated": self.auth_token is not None,
+        }
+
+    async def search(
+        self,
+        query: str,
+        limit: int = 20,
+    ) -> list[HubSkillInfo]:
+        """Search for skills matching a query.
+
+        Args:
+            query: Search query string
+            limit: Maximum number of results
+
+        Returns:
+            List of matching skills with basic info
+        """
+        result = await self._make_request(
+            method="POST",
+            endpoint="/skills/search",
+            json_data={"query": query, "limit": limit},
+        )
+
+        skills = result.get("skills", [])
+        return [
+            HubSkillInfo(
+                slug=skill.get("slug", skill.get("name", "")),
+                display_name=skill.get("name", skill.get("slug", "")),
+                description=skill.get("description", ""),
+                hub_name=self.hub_name,
+                version=skill.get("version"),
+                score=skill.get("score"),
+            )
+            for skill in skills
+        ]
+
+    async def list_skills(
+        self,
+        limit: int = 50,
+        offset: int = 0,
+    ) -> list[HubSkillInfo]:
+        """List available skills from the hub.
+
+        Args:
+            limit: Maximum number of results
+            offset: Number of results to skip
+
+        Returns:
+            List of skills with basic info
+        """
+        result = await self._make_request(
+            method="GET",
+            endpoint="/skills/catalog",
+            params={"limit": limit, "offset": offset},
+        )
+
+        skills = result.get("skills", [])
+        return [
+            HubSkillInfo(
+                slug=skill.get("slug", skill.get("name", "")),
+                display_name=skill.get("name", skill.get("slug", "")),
+                description=skill.get("description", ""),
+                hub_name=self.hub_name,
+                version=skill.get("version"),
+            )
+            for skill in skills
+        ]
+
+    async def get_skill_details(
+        self,
+        slug: str,
+    ) -> HubSkillDetails | None:
+        """Get detailed information about a specific skill.
+
+        Args:
+            slug: The skill's unique identifier
+
+        Returns:
+            Detailed skill info, or None if not found
+        """
+        try:
+            result = await self._make_request(
+                method="GET",
+                endpoint=f"/skills/{slug}",
+            )
+
+            if not result:
+                return None
+
+            return HubSkillDetails(
+                slug=result.get("slug", slug),
+                display_name=result.get("name", slug),
+                description=result.get("description", ""),
+                hub_name=self.hub_name,
+                version=result.get("version"),
+                latest_version=result.get("latest_version", result.get("version")),
+                versions=result.get("versions", []),
+            )
+        except RuntimeError:
+            return None
+
+    async def download_skill(
+        self,
+        slug: str,
+        version: str | None = None,
+        target_dir: str | None = None,
+    ) -> DownloadResult:
+        """Download and extract a skill from the hub.
+
+        Args:
+            slug: The skill's unique identifier
+            version: Specific version to download (None for latest)
+            target_dir: Directory to extract to
+
+        Returns:
+            DownloadResult with success status, path, version, or error
+        """
+        # Get download URL from API
+        params: dict[str, Any] = {}
+        if version:
+            params["version"] = version
+
+        result = await self._make_request(
+            method="GET",
+            endpoint=f"/skills/{slug}/download",
+            params=params if params else None,
+        )
+
+        download_url = result.get("download_url", "")
+
+        if download_url:
+            path = await self._download_and_extract(download_url, target_dir)
+            return DownloadResult(
+                success=True,
+                slug=slug,
+                path=path,
+                version=result.get("version", version),
+            )
+
+        return DownloadResult(
+            success=False,
+            slug=slug,
+            error="No download URL provided",
+        )

gobby/skills/parser.py

@@ -64,6 +64,8 @@ class ParsedSkill:
         scripts: List of script file paths (relative to skill dir)
         references: List of reference file paths (relative to skill dir)
         assets: List of asset file paths (relative to skill dir)
+        always_apply: Whether skill should always be injected at session start
+        injection_format: How to inject skill (summary, full, content)
     """
 
     name: str
@@ -80,6 +82,8 @@ class ParsedSkill:
     scripts: list[str] | None = None
     references: list[str] | None = None
     assets: list[str] | None = None
+    always_apply: bool = False
+    injection_format: str = "summary"
 
     def get_category(self) -> str | None:
         """Get category from top-level or metadata.skillport.category."""
@@ -139,6 +143,8 @@ class ParsedSkill:
             "scripts": self.scripts,
             "references": self.references,
             "assets": self.assets,
+            "always_apply": self.always_apply,
+            "injection_format": self.injection_format,
         }
 
 
@@ -232,6 +238,7 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     # This allows both top-level and nested formats to work
     top_level_always_apply = frontmatter.get("alwaysApply")
     top_level_category = frontmatter.get("category")
+    top_level_injection_format = frontmatter.get("injectionFormat")
 
     if top_level_always_apply is not None or top_level_category is not None:
         if metadata is None:
@@ -251,6 +258,20 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
     if version is not None:
         version = str(version)
 
+    # Extract always_apply: check top-level first, then metadata.skillport.alwaysApply
+    always_apply = False
+    if top_level_always_apply is not None:
+        always_apply = bool(top_level_always_apply)
+    elif metadata and isinstance(metadata, dict):
+        skillport = metadata.get("skillport", {})
+        if isinstance(skillport, dict) and skillport.get("alwaysApply"):
+            always_apply = bool(skillport["alwaysApply"])
+
+    # Extract injection_format: check top-level first, default to "summary"
+    injection_format = "summary"
+    if top_level_injection_format is not None:
+        injection_format = str(top_level_injection_format)
+
     return ParsedSkill(
         name=name,
         description=description,
@@ -261,6 +282,8 @@ def parse_skill_text(text: str, source_path: str | None = None) -> ParsedSkill:
         allowed_tools=allowed_tools,
         metadata=metadata,
         source_path=source_path,
+        always_apply=always_apply,
+        injection_format=injection_format,
     )
 
 

gobby/skills/sync.py

@@ -23,10 +23,9 @@ def get_bundled_skills_path() -> Path:
     Returns:
         Path to src/gobby/install/shared/skills/
     """
-    # Navigate from this file to install/shared/skills/
-    # This file: src/gobby/skills/sync.py
-    # Target: src/gobby/install/shared/skills/
-    return Path(__file__).parent.parent / "install" / "shared" / "skills"
+    from gobby.paths import get_install_dir
+
+    return get_install_dir() / "shared" / "skills"
 
 
 def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
@@ -101,6 +100,8 @@ def sync_bundled_skills(db: DatabaseProtocol) -> dict[str, Any]:
                 source_ref=None,
                 project_id=None,  # Global scope
                 enabled=True,
+                always_apply=parsed.always_apply,
+                injection_format=parsed.injection_format,
             )
 
             logger.info(f"Synced bundled skill: {parsed.name}")