skill-seekers 2.7.3__py3-none-any.whl

skill_seekers/__init__.py

@@ -0,0 +1,22 @@
+"""
+Skill Seekers - Convert documentation, GitHub repos, and PDFs into Claude AI skills.
+
+This package provides tools for automatically scraping, organizing, and packaging
+documentation from various sources into uploadable Claude AI skills.
+"""
+
+__version__ = "2.7.2"
+__author__ = "Yusuf Karaaslan"
+__license__ = "MIT"
+
+# Expose main components for easier imports
+from skill_seekers.cli import __version__ as cli_version
+from skill_seekers.mcp import __version__ as mcp_version
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__license__",
+    "cli_version",
+    "mcp_version",
+]

skill_seekers/cli/__init__.py

@@ -0,0 +1,39 @@
+"""Skill Seekers CLI tools package.
+
+This package provides command-line tools for converting documentation
+websites into Claude AI skills.
+
+Main modules:
+    - doc_scraper: Main documentation scraping and skill building tool
+    - llms_txt_detector: Detect llms.txt files at documentation URLs
+    - llms_txt_downloader: Download llms.txt content
+    - llms_txt_parser: Parse llms.txt markdown content
+    - pdf_scraper: Extract documentation from PDF files
+    - enhance_skill: AI-powered skill enhancement (API-based)
+    - enhance_skill_local: AI-powered skill enhancement (local)
+    - estimate_pages: Estimate page count before scraping
+    - package_skill: Package skills into .zip files
+    - upload_skill: Upload skills to Claude
+    - utils: Shared utility functions
+"""
+
+from .llms_txt_detector import LlmsTxtDetector
+from .llms_txt_downloader import LlmsTxtDownloader
+from .llms_txt_parser import LlmsTxtParser
+
+try:
+    from .utils import open_folder, read_reference_files
+except ImportError:
+    # utils.py might not exist in all configurations
+    open_folder = None
+    read_reference_files = None
+
+__version__ = "2.7.2"
+
+__all__ = [
+    "LlmsTxtDetector",
+    "LlmsTxtDownloader",
+    "LlmsTxtParser",
+    "open_folder",
+    "read_reference_files",
+]

skill_seekers/cli/adaptors/__init__.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Multi-LLM Adaptor Registry
+
+Provides factory function to get platform-specific adaptors for skill generation.
+Supports Claude AI, Google Gemini, OpenAI ChatGPT, and generic Markdown export.
+"""
+
+from .base import SkillAdaptor, SkillMetadata
+
+# Import adaptors (some may not be implemented yet)
+try:
+    from .claude import ClaudeAdaptor
+except ImportError:
+    ClaudeAdaptor = None
+
+try:
+    from .gemini import GeminiAdaptor
+except ImportError:
+    GeminiAdaptor = None
+
+try:
+    from .openai import OpenAIAdaptor
+except ImportError:
+    OpenAIAdaptor = None
+
+try:
+    from .markdown import MarkdownAdaptor
+except ImportError:
+    MarkdownAdaptor = None
+
+
+# Registry of available adaptors
+ADAPTORS: dict[str, type[SkillAdaptor]] = {}
+
+# Register adaptors that are implemented
+if ClaudeAdaptor:
+    ADAPTORS["claude"] = ClaudeAdaptor
+if GeminiAdaptor:
+    ADAPTORS["gemini"] = GeminiAdaptor
+if OpenAIAdaptor:
+    ADAPTORS["openai"] = OpenAIAdaptor
+if MarkdownAdaptor:
+    ADAPTORS["markdown"] = MarkdownAdaptor
+
+
+def get_adaptor(platform: str, config: dict = None) -> SkillAdaptor:
+    """
+    Factory function to get platform-specific adaptor instance.
+
+    Args:
+        platform: Platform identifier ('claude', 'gemini', 'openai', 'markdown')
+        config: Optional platform-specific configuration
+
+    Returns:
+        SkillAdaptor instance for the specified platform
+
+    Raises:
+        ValueError: If platform is not supported or not yet implemented
+
+    Examples:
+        >>> adaptor = get_adaptor('claude')
+        >>> adaptor = get_adaptor('gemini', {'api_version': 'v1beta'})
+    """
+    if platform not in ADAPTORS:
+        available = ", ".join(ADAPTORS.keys())
+        if not ADAPTORS:
+            raise ValueError(
+                f"No adaptors are currently implemented. Platform '{platform}' is not available."
+            )
+        raise ValueError(
+            f"Platform '{platform}' is not supported or not yet implemented. Available platforms: {available}"
+        )
+
+    adaptor_class = ADAPTORS[platform]
+    return adaptor_class(config)
+
+
+def list_platforms() -> list[str]:
+    """
+    List all supported platforms.
+
+    Returns:
+        List of platform identifiers
+
+    Examples:
+        >>> list_platforms()
+        ['claude', 'gemini', 'openai', 'markdown']
+    """
+    return list(ADAPTORS.keys())
+
+
+def is_platform_available(platform: str) -> bool:
+    """
+    Check if a platform adaptor is available.
+
+    Args:
+        platform: Platform identifier to check
+
+    Returns:
+        True if platform is available
+
+    Examples:
+        >>> is_platform_available('claude')
+        True
+        >>> is_platform_available('unknown')
+        False
+    """
+    return platform in ADAPTORS
+
+
+# Export public interface
+__all__ = [
+    "SkillAdaptor",
+    "SkillMetadata",
+    "get_adaptor",
+    "list_platforms",
+    "is_platform_available",
+    "ADAPTORS",
+]

skill_seekers/cli/adaptors/base.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""
+Base Adaptor for Multi-LLM Support
+
+Defines the abstract interface that all platform-specific adaptors must implement.
+This enables Skill Seekers to generate skills for multiple LLM platforms (Claude, Gemini, ChatGPT).
+"""
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+@dataclass
+class SkillMetadata:
+    """Universal skill metadata used across all platforms"""
+
+    name: str
+    description: str
+    version: str = "1.0.0"
+    author: str | None = None
+    tags: list[str] = field(default_factory=list)
+
+
+class SkillAdaptor(ABC):
+    """
+    Abstract base class for platform-specific skill adaptors.
+
+    Each platform (Claude, Gemini, OpenAI) implements this interface to handle:
+    - Platform-specific SKILL.md formatting
+    - Platform-specific package structure (ZIP, tar.gz, etc.)
+    - Platform-specific upload endpoints and authentication
+    - Optional AI enhancement capabilities
+    """
+
+    # Platform identifiers (override in subclasses)
+    PLATFORM: str = "unknown"  # e.g., "claude", "gemini", "openai"
+    PLATFORM_NAME: str = "Unknown"  # e.g., "Claude AI (Anthropic)"
+    DEFAULT_API_ENDPOINT: str | None = None
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        """
+        Initialize adaptor with optional configuration.
+
+        Args:
+            config: Platform-specific configuration options
+        """
+        self.config = config or {}
+
+    @abstractmethod
+    def format_skill_md(self, skill_dir: Path, metadata: SkillMetadata) -> str:
+        """
+        Format SKILL.md content with platform-specific frontmatter/structure.
+
+        Different platforms require different formats:
+        - Claude: YAML frontmatter + markdown
+        - Gemini: Plain markdown (no frontmatter)
+        - OpenAI: Assistant instructions format
+
+        Args:
+            skill_dir: Path to skill directory containing references/
+            metadata: Skill metadata (name, description, version, etc.)
+
+        Returns:
+            Formatted SKILL.md content as string
+        """
+        pass
+
+    @abstractmethod
+    def package(self, skill_dir: Path, output_path: Path) -> Path:
+        """
+        Package skill for platform (ZIP, tar.gz, etc.).
+
+        Different platforms require different package formats:
+        - Claude: .zip with SKILL.md, references/, scripts/, assets/
+        - Gemini: .tar.gz with system_instructions.md, references/
+        - OpenAI: .zip with assistant_instructions.txt, vector_store_files/
+
+        Args:
+            skill_dir: Path to skill directory to package
+            output_path: Path for output package (file or directory)
+
+        Returns:
+            Path to created package file
+        """
+        pass
+
+    @abstractmethod
+    def upload(self, package_path: Path, api_key: str, **kwargs) -> dict[str, Any]:
+        """
+        Upload packaged skill to platform.
+
+        Returns a standardized response dictionary for all platforms.
+
+        Args:
+            package_path: Path to packaged skill file
+            api_key: Platform API key
+            **kwargs: Additional platform-specific arguments
+
+        Returns:
+            Dictionary with keys:
+            - success (bool): Whether upload succeeded
+            - skill_id (str|None): Platform-specific skill/assistant ID
+            - url (str|None): URL to view/manage skill
+            - message (str): Success or error message
+        """
+        pass
+
+    def validate_api_key(self, api_key: str) -> bool:
+        """
+        Validate API key format for this platform.
+
+        Default implementation just checks if key is non-empty.
+        Override for platform-specific validation.
+
+        Args:
+            api_key: API key to validate
+
+        Returns:
+            True if key format is valid
+        """
+        return bool(api_key and api_key.strip())
+
+    def get_env_var_name(self) -> str:
+        """
+        Get expected environment variable name for API key.
+
+        Returns:
+            Environment variable name (e.g., "ANTHROPIC_API_KEY", "GOOGLE_API_KEY")
+        """
+        return f"{self.PLATFORM.upper()}_API_KEY"
+
+    def supports_enhancement(self) -> bool:
+        """
+        Whether this platform supports AI-powered SKILL.md enhancement.
+
+        Returns:
+            True if platform can enhance skills
+        """
+        return False
+
+    def enhance(self, _skill_dir: Path, _api_key: str) -> bool:
+        """
+        Optionally enhance SKILL.md using platform's AI.
+
+        Only called if supports_enhancement() returns True.
+
+        Args:
+            skill_dir: Path to skill directory
+            api_key: Platform API key
+
+        Returns:
+            True if enhancement succeeded
+        """
+        return False
+
+    def _read_existing_content(self, skill_dir: Path) -> str:
+        """
+        Helper to read existing SKILL.md content (without frontmatter).
+
+        Args:
+            skill_dir: Path to skill directory
+
+        Returns:
+            SKILL.md content without YAML frontmatter
+        """
+        skill_md_path = skill_dir / "SKILL.md"
+        if not skill_md_path.exists():
+            return ""
+
+        content = skill_md_path.read_text(encoding="utf-8")
+
+        # Strip YAML frontmatter if present
+        if content.startswith("---"):
+            parts = content.split("---", 2)
+            if len(parts) >= 3:
+                return parts[2].strip()
+
+        return content
+
+    def _extract_quick_reference(self, skill_dir: Path) -> str:
+        """
+        Helper to extract quick reference section from references.
+
+        Args:
+            skill_dir: Path to skill directory
+
+        Returns:
+            Quick reference content as markdown string
+        """
+        index_path = skill_dir / "references" / "index.md"
+        if not index_path.exists():
+            return "See references/ directory for documentation."
+
+        # Read index and extract relevant sections
+        content = index_path.read_text(encoding="utf-8")
+        return content[:500] + "..." if len(content) > 500 else content
+
+    def _generate_toc(self, skill_dir: Path) -> str:
+        """
+        Helper to generate table of contents from references.
+
+        Args:
+            skill_dir: Path to skill directory
+
+        Returns:
+            Table of contents as markdown string
+        """
+        refs_dir = skill_dir / "references"
+        if not refs_dir.exists():
+            return ""
+
+        toc_lines = []
+        for ref_file in sorted(refs_dir.glob("*.md")):
+            if ref_file.name == "index.md":
+                continue
+            title = ref_file.stem.replace("_", " ").title()
+            toc_lines.append(f"- [{title}](references/{ref_file.name})")
+
+        return "\n".join(toc_lines)