kubiya-control-plane-api 0.9.15__py3-none-any.whl

control_plane_api/app/skills/config.py

@@ -0,0 +1,63 @@
+"""
+Skills Configuration
+
+Environment variable based configuration for dynamic skill loading.
+"""
+
+import os
+from pathlib import Path
+from typing import List
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def get_skill_template_paths() -> List[str]:
+    """
+    Get skill template paths from environment variables.
+
+    Environment Variables:
+        KUBIYA_SKILLS_TEMPLATES_PATH: Primary skills template directory
+        KUBIYA_SKILLS_EXTRA_PATHS: Additional paths (colon-separated on Unix, semicolon on Windows)
+
+    Returns:
+        List of paths to search for skill templates
+    """
+    paths = []
+
+    # Primary path from environment
+    primary_path = os.getenv("KUBIYA_SKILLS_TEMPLATES_PATH")
+    if primary_path:
+        paths.append(primary_path)
+
+    # Extra paths (colon-separated on Unix, semicolon on Windows)
+    extra_paths_str = os.getenv("KUBIYA_SKILLS_EXTRA_PATHS", "")
+    separator = ";" if os.name == "nt" else ":"
+    extra_paths = [p.strip() for p in extra_paths_str.split(separator) if p.strip()]
+    paths.extend(extra_paths)
+
+    # Default: ~/.kubiya/skills if nothing configured
+    if not paths:
+        default_path = Path.home() / ".kubiya" / "skills"
+        if default_path.exists():
+            paths.append(str(default_path))
+
+    logger.info(f"Skill template paths configured: {paths}")
+    return paths
+
+
+def is_dynamic_skills_enabled() -> bool:
+    """
+    Check if dynamic skill loading is enabled.
+
+    Environment Variable:
+        KUBIYA_ENABLE_DYNAMIC_SKILLS: Set to 'true', '1', or 'yes' to enable
+
+    Returns:
+        True if dynamic skills are enabled
+    """
+    enabled_str = os.getenv("KUBIYA_ENABLE_DYNAMIC_SKILLS", "true").lower()
+    enabled = enabled_str in ("true", "1", "yes")
+
+    logger.info(f"Dynamic skills loading enabled: {enabled}")
+    return enabled

control_plane_api/app/skills/loaders/__init__.py

@@ -0,0 +1,14 @@
+"""
+Skill Template Loaders
+
+Loaders for discovering and loading skill templates from various sources.
+Control Plane uses these to dynamically discover available skills.
+"""
+
+from .base import BaseSkillTemplateLoader
+from .filesystem_loader import FilesystemSkillTemplateLoader
+
+__all__ = [
+    "BaseSkillTemplateLoader",
+    "FilesystemSkillTemplateLoader",
+]

control_plane_api/app/skills/loaders/base.py

@@ -0,0 +1,73 @@
+"""
+Base Skill Template Loader
+
+Abstract interface for all skill template loaders.
+"""
+
+from abc import ABC, abstractmethod
+from typing import List
+import logging
+
+from control_plane_api.app.skills.base import SkillDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class BaseSkillTemplateLoader(ABC):
+    """
+    Abstract base class for skill template loaders.
+
+    Loaders discover skill templates from various sources and return
+    SkillDefinition instances that can be registered in the skill registry.
+    """
+
+    def __init__(self, enabled: bool = True):
+        """
+        Initialize loader.
+
+        Args:
+            enabled: Whether this loader is enabled
+        """
+        self.enabled = enabled
+        self.logger = logger
+
+    @abstractmethod
+    def discover(self) -> List[SkillDefinition]:
+        """
+        Discover skill templates from this source.
+
+        Returns:
+            List of SkillDefinition instances
+
+        Raises:
+            Exception: If discovery fails
+        """
+        pass
+
+    def get_source_name(self) -> str:
+        """
+        Get the name of this loader source.
+
+        Returns:
+            Source name for logging
+        """
+        return self.__class__.__name__
+
+    def is_enabled(self) -> bool:
+        """
+        Check if this loader is enabled.
+
+        Returns:
+            True if enabled
+        """
+        return self.enabled
+
+    def enable(self) -> None:
+        """Enable this loader."""
+        self.enabled = True
+        self.logger.info(f"{self.get_source_name()} enabled")
+
+    def disable(self) -> None:
+        """Disable this loader."""
+        self.enabled = False
+        self.logger.info(f"{self.get_source_name()} disabled")

control_plane_api/app/skills/loaders/filesystem_loader.py

@@ -0,0 +1,199 @@
+"""
+Filesystem Skill Template Loader
+
+Loads skill templates from filesystem directories containing Python skill definitions.
+"""
+
+import sys
+import importlib.util
+from pathlib import Path
+from typing import List
+import logging
+
+from .base import BaseSkillTemplateLoader
+from control_plane_api.app.skills.base import SkillDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class FilesystemSkillTemplateLoader(BaseSkillTemplateLoader):
+    """
+    Loader for filesystem-based skill templates.
+
+    Discovers skill templates by searching for skill_template.py files
+    in configured directories (e.g., ~/.kubiya/skills/).
+
+    Directory structure:
+        ~/.kubiya/skills/
+        ├── my_custom_skill/
+        │   └── skill_template.py  # Contains SkillDefinition subclass
+        └── another_skill/
+            └── skill_template.py
+    """
+
+    def __init__(
+        self,
+        base_paths: List[str] = None,
+        enabled: bool = True,
+    ):
+        """
+        Initialize filesystem loader.
+
+        Args:
+            base_paths: List of base directories to search
+            enabled: Whether this loader is enabled
+        """
+        super().__init__(enabled=enabled)
+
+        # Default paths
+        if base_paths is None:
+            base_paths = []
+            # Add .kubiya/skills/ from home directory
+            home_skills = Path.home() / ".kubiya" / "skills"
+            if home_skills.exists():
+                base_paths.append(str(home_skills))
+
+        self.base_paths = [Path(p) for p in base_paths]
+        logger.info(
+            f"FilesystemSkillTemplateLoader initialized with paths: {[str(p) for p in self.base_paths]}"
+        )
+
+    def discover(self) -> List[SkillDefinition]:
+        """
+        Discover skill templates by scanning for skill_template.py files.
+
+        Returns:
+            List of discovered SkillDefinition instances
+        """
+        discovered = []
+
+        for base_path in self.base_paths:
+            if not base_path.exists():
+                logger.warning(f"Base path not found: {base_path}")
+                continue
+
+            # Search for skill template files
+            skill_dirs = self._find_skill_directories(base_path)
+
+            for skill_dir in skill_dirs:
+                try:
+                    skill_def = self._load_skill_template(skill_dir)
+                    if skill_def:
+                        discovered.append(skill_def)
+                        logger.info(
+                            f"Loaded skill template: {skill_def.name} from {skill_dir}"
+                        )
+                except Exception as e:
+                    logger.error(
+                        f"Failed to load skill template from {skill_dir}: {e}",
+                        exc_info=True
+                    )
+
+        logger.info(f"Discovered {len(discovered)} skill templates from filesystem")
+        return discovered
+
+    def _find_skill_directories(self, base_path: Path) -> List[Path]:
+        """
+        Find all directories containing skill_template.py files.
+
+        Args:
+            base_path: Base directory to search
+
+        Returns:
+            List of directories containing skill templates
+        """
+        skill_dirs = []
+
+        for item in base_path.iterdir():
+            if item.is_dir():
+                skill_template = item / "skill_template.py"
+                if skill_template.exists():
+                    skill_dirs.append(item)
+
+        return skill_dirs
+
+    def _load_skill_template(self, skill_dir: Path) -> SkillDefinition:
+        """
+        Load skill template from a directory.
+
+        Args:
+            skill_dir: Directory containing skill_template.py
+
+        Returns:
+            SkillDefinition instance
+
+        Raises:
+            Exception: If loading fails
+        """
+        skill_template_path = skill_dir / "skill_template.py"
+
+        # Add skill directory to path temporarily
+        skill_dir_str = str(skill_dir)
+        if skill_dir_str not in sys.path:
+            sys.path.insert(0, skill_dir_str)
+
+        try:
+            # Load the module dynamically
+            module_name = f"skill_template_{skill_dir.name}"
+            spec = importlib.util.spec_from_file_location(
+                module_name,
+                skill_template_path
+            )
+
+            if spec is None or spec.loader is None:
+                raise ImportError(f"Could not load module spec from {skill_template_path}")
+
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+
+            # Find SkillDefinition subclass in module
+            skill_class = None
+            for attr_name in dir(module):
+                attr = getattr(module, attr_name)
+                if (
+                    isinstance(attr, type) and
+                    issubclass(attr, SkillDefinition) and
+                    attr is not SkillDefinition
+                ):
+                    skill_class = attr
+                    break
+
+            if skill_class is None:
+                raise ValueError(
+                    f"No SkillDefinition subclass found in {skill_template_path}"
+                )
+
+            # Instantiate the skill definition
+            skill_instance = skill_class()
+
+            return skill_instance
+
+        finally:
+            # Clean up sys.path
+            if skill_dir_str in sys.path:
+                sys.path.remove(skill_dir_str)
+
+    def add_base_path(self, path: str) -> None:
+        """
+        Add an additional base path to search.
+
+        Args:
+            path: Path to add
+        """
+        path_obj = Path(path)
+        if path_obj not in self.base_paths:
+            self.base_paths.append(path_obj)
+            logger.info(f"Added base path: {path_obj}")
+
+    def remove_base_path(self, path: str) -> None:
+        """
+        Remove a base path from search.
+
+        Args:
+            path: Path to remove
+        """
+        path_obj = Path(path)
+        if path_obj in self.base_paths:
+            self.base_paths.remove(path_obj)
+            logger.info(f"Removed base path: {path_obj}")

control_plane_api/app/skills/registry.py

@@ -0,0 +1,125 @@
+"""
+Skill Registry
+
+Central registry for all available skills. Skills self-register
+when their modules are imported, or can be loaded dynamically from external sources.
+"""
+from typing import Dict, List, Optional
+from .base import SkillDefinition, SkillType
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class SkillRegistry:
+    """Registry for all available skill definitions"""
+
+    def __init__(self):
+        self._skills: Dict[SkillType, SkillDefinition] = {}
+        self._dynamic_loaded = False
+
+    def register(self, skill: SkillDefinition):
+        """Register a skill definition"""
+        if skill.type in self._skills:
+            logger.warning(f"Skill {skill.type} is already registered, overwriting")
+
+        self._skills[skill.type] = skill
+        logger.info(f"Registered skill: {skill.type} - {skill.name}")
+
+    def load_from_loaders(self, loaders: List) -> int:
+        """
+        Load skills from multiple loaders.
+
+        Args:
+            loaders: List of BaseSkillTemplateLoader instances
+
+        Returns:
+            Number of skills loaded
+        """
+        loaded_count = 0
+
+        for loader in loaders:
+            if not loader.is_enabled():
+                logger.info(f"Skipping disabled loader: {loader.get_source_name()}")
+                continue
+
+            try:
+                logger.info(f"Loading skills from: {loader.get_source_name()}")
+                skills = loader.discover()
+
+                for skill in skills:
+                    try:
+                        self.register(skill)
+                        loaded_count += 1
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to register skill {skill.name}: {e}",
+                            exc_info=True
+                        )
+
+            except Exception as e:
+                logger.error(
+                    f"Loader {loader.get_source_name()} failed: {e}",
+                    exc_info=True
+                )
+
+        self._dynamic_loaded = True
+        logger.info(f"Loaded {loaded_count} skills from {len(loaders)} loaders")
+        return loaded_count
+
+    def get(self, skill_type: SkillType) -> Optional[SkillDefinition]:
+        """Get a skill definition by type"""
+        return self._skills.get(skill_type)
+
+    def get_all(self) -> List[SkillDefinition]:
+        """Get all registered skills"""
+        return list(self._skills.values())
+
+    def get_by_name(self, name: str) -> Optional[SkillDefinition]:
+        """Get a skill by name"""
+        for skill in self._skills.values():
+            if skill.name.lower() == name.lower():
+                return skill
+        return None
+
+    def list_types(self) -> List[SkillType]:
+        """List all registered skill types"""
+        return list(self._skills.keys())
+
+    def is_dynamic_loaded(self) -> bool:
+        """Check if dynamic skills have been loaded"""
+        return self._dynamic_loaded
+
+    def get_stats(self) -> Dict[str, any]:
+        """
+        Get registry statistics.
+
+        Returns:
+            Dictionary with registry stats
+        """
+        return {
+            "total_skills": len(self._skills),
+            "skill_types": [str(st) for st in self._skills.keys()],
+            "skill_names": [skill.name for skill in self._skills.values()],
+            "dynamic_loaded": self._dynamic_loaded,
+        }
+
+
+# Global registry instance
+skill_registry = SkillRegistry()
+
+
+def register_skill(skill: SkillDefinition):
+    """Decorator or function to register a skill"""
+    skill_registry.register(skill)
+    return skill
+
+
+def get_skill(skill_type: SkillType) -> Optional[SkillDefinition]:
+    """Get a skill definition by type"""
+    return skill_registry.get(skill_type)
+
+
+def get_all_skills() -> List[SkillDefinition]:
+    """Get all registered skills"""
+    return skill_registry.get_all()

control_plane_api/app/utils/helpers.py

@@ -0,0 +1,12 @@
+import os
+
+
+def is_local_temporal() -> bool:
+    """
+    Check if the Temporal running temporal is in a docker container or not.
+    """
+    temporal_host = os.getenv("TEMPORAL_HOST", "us-east-1.aws.api.temporal.io:7233")
+    return any([
+        temporal_host.startswith("temporal:"),
+        temporal_host.startswith("host.docker.internal"),
+    ])