gobby 0.2.9__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/storage/memories.py

@@ -145,11 +145,11 @@ class LocalMemoryManager:
 
         now = datetime.now(UTC).isoformat()
         # Normalize content for consistent ID generation (avoid duplicates from
-        # whitespace differences or project_id inconsistency)
+        # whitespace differences)
         normalized_content = content.strip()
-        project_str = project_id if project_id else ""
-        # Use delimiter to prevent collisions (e.g., "abc" + "def" vs "abcd" + "ef")
-        memory_id = generate_prefixed_id("mm", f"{normalized_content}||{project_str}")
+        # Global dedup: ID based on content only (project_id stored but not in ID)
+        # This aligns with content_exists() which checks globally
+        memory_id = generate_prefixed_id("mm", normalized_content)
 
         # Check if memory already exists to avoid duplicate insert errors
         existing_row = self.db.fetchone("SELECT * FROM memories WHERE id = ?", (memory_id,))