kubiya-control-plane-api 0.1.0__py3-none-any.whl → 0.3.4__py3-none-any.whl

control_plane_api/app/skills/data_visualization.py

@@ -0,0 +1,154 @@
+"""
+Data Visualization Skill
+
+Provides data visualization and diagramming capabilities using Mermaid syntax.
+Agents can create flowcharts, sequence diagrams, class diagrams, ER diagrams,
+and other visualizations for data intelligence and business intelligence use cases.
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from .registry import register_skill
+
+
+class DataVisualizationSkill(SkillDefinition):
+    """Data visualization and diagramming skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.DATA_VISUALIZATION
+
+    @property
+    def name(self) -> str:
+        return "Data Visualization"
+
+    @property
+    def description(self) -> str:
+        return "Create diagrams and visualizations using Mermaid syntax for data analysis and BI intelligence"
+
+    @property
+    def icon(self) -> str:
+        return "BarChart3"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="diagramming_full",
+                name="Full Diagramming Suite",
+                description="All diagram types: flowcharts, sequences, class diagrams, ER diagrams, Gantt charts, and more",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="BarChart3",
+                configuration={
+                    "enable_flowchart": True,
+                    "enable_sequence": True,
+                    "enable_class_diagram": True,
+                    "enable_er_diagram": True,
+                    "enable_gantt": True,
+                    "enable_pie_chart": True,
+                    "enable_state_diagram": True,
+                    "enable_git_graph": True,
+                    "enable_user_journey": True,
+                    "enable_quadrant_chart": True,
+                    "max_diagram_size": 50000,  # Max characters per diagram
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="diagramming_data_viz",
+                name="Data Visualization",
+                description="Focus on data visualization: charts, ER diagrams, and analytics diagrams",
+                category=SkillCategory.COMMON,
+                badge="Analytics",
+                icon="PieChart",
+                configuration={
+                    "enable_flowchart": False,
+                    "enable_sequence": False,
+                    "enable_class_diagram": False,
+                    "enable_er_diagram": True,
+                    "enable_gantt": True,
+                    "enable_pie_chart": True,
+                    "enable_state_diagram": False,
+                    "enable_git_graph": False,
+                    "enable_user_journey": False,
+                    "enable_quadrant_chart": True,
+                    "max_diagram_size": 30000,
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="diagramming_technical",
+                name="Technical Diagrams",
+                description="Technical diagrams: flowcharts, sequences, class diagrams, state machines",
+                category=SkillCategory.ADVANCED,
+                badge="Engineering",
+                icon="GitBranch",
+                configuration={
+                    "enable_flowchart": True,
+                    "enable_sequence": True,
+                    "enable_class_diagram": True,
+                    "enable_er_diagram": True,
+                    "enable_gantt": False,
+                    "enable_pie_chart": False,
+                    "enable_state_diagram": True,
+                    "enable_git_graph": True,
+                    "enable_user_journey": False,
+                    "enable_quadrant_chart": False,
+                    "max_diagram_size": 50000,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate diagramming configuration"""
+        validated = {
+            "enable_flowchart": config.get("enable_flowchart", True),
+            "enable_sequence": config.get("enable_sequence", True),
+            "enable_class_diagram": config.get("enable_class_diagram", True),
+            "enable_er_diagram": config.get("enable_er_diagram", True),
+            "enable_gantt": config.get("enable_gantt", True),
+            "enable_pie_chart": config.get("enable_pie_chart", True),
+            "enable_state_diagram": config.get("enable_state_diagram", True),
+            "enable_git_graph": config.get("enable_git_graph", True),
+            "enable_user_journey": config.get("enable_user_journey", True),
+            "enable_quadrant_chart": config.get("enable_quadrant_chart", True),
+        }
+
+        # Add max_diagram_size if specified
+        max_size = config.get("max_diagram_size", 50000)
+        validated["max_diagram_size"] = min(max_size, 100000)  # Cap at 100k characters
+
+        # Add optional theme settings
+        if "theme" in config:
+            theme = config["theme"]
+            if theme in ["default", "dark", "forest", "neutral"]:
+                validated["theme"] = theme
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: all diagram types enabled"""
+        return {
+            "enable_flowchart": True,
+            "enable_sequence": True,
+            "enable_class_diagram": True,
+            "enable_er_diagram": True,
+            "enable_gantt": True,
+            "enable_pie_chart": True,
+            "enable_state_diagram": True,
+            "enable_git_graph": True,
+            "enable_user_journey": True,
+            "enable_quadrant_chart": True,
+            "max_diagram_size": 50000,
+        }
+
+    def get_framework_class_name(self) -> str:
+        """
+        Get the underlying framework tool class name.
+        Returns the class name for DiagrammingTools.
+        """
+        return "DataVisualizationTools"
+
+
+# Auto-register this skill
+register_skill(DataVisualizationSkill())

control_plane_api/app/skills/docker.py

@@ -0,0 +1,104 @@
+"""
+Docker Skill
+
+Provides Docker management capabilities (containers, images, volumes, networks).
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant, SkillRequirements
+from .registry import register_skill
+
+
+class DockerSkill(SkillDefinition):
+    """Docker management skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.DOCKER
+
+    @property
+    def name(self) -> str:
+        return "Docker"
+
+    @property
+    def description(self) -> str:
+        return "Manage Docker containers, images, volumes, and networks on the local system"
+
+    @property
+    def icon(self) -> str:
+        return "FaDocker"
+
+    @property
+    def icon_type(self) -> str:
+        return "react-icon"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="docker_containers",
+                name="Docker - Containers",
+                description="Manage Docker containers on local system (start, stop, inspect)",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FaDocker",
+                configuration={
+                    "enable_container_management": True,
+                    "enable_image_management": False,
+                    "enable_volume_management": False,
+                    "enable_network_management": False,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="docker_full_control",
+                name="Docker - Full Control",
+                description="Complete Docker management: containers, images, volumes, and networks",
+                category=SkillCategory.ADVANCED,
+                badge="Advanced",
+                icon="FaDocker",
+                configuration={
+                    "enable_container_management": True,
+                    "enable_image_management": True,
+                    "enable_volume_management": True,
+                    "enable_network_management": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate Docker configuration"""
+        validated = {
+            "enable_container_management": config.get("enable_container_management", True),
+            "enable_image_management": config.get("enable_image_management", False),
+            "enable_volume_management": config.get("enable_volume_management", False),
+            "enable_network_management": config.get("enable_network_management", False),
+        }
+
+        # Add docker_host if specified (e.g., "unix:///var/run/docker.sock")
+        if "docker_host" in config:
+            validated["docker_host"] = str(config["docker_host"])
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: container management only"""
+        return {
+            "enable_container_management": True,
+            "enable_image_management": False,
+            "enable_volume_management": False,
+            "enable_network_management": False,
+        }
+
+    def get_requirements(self) -> SkillRequirements:
+        """Docker skill requires docker package and Docker daemon"""
+        return SkillRequirements(
+            python_packages=["docker>=6.0.0"],
+            system_packages=["docker"],
+            supported_os=["linux", "darwin", "windows"],
+            external_dependencies=["Docker daemon must be running"],
+            notes="Requires Docker to be installed and the Docker daemon to be accessible"
+        )
+
+
+# Auto-register this skill
+register_skill(DockerSkill())

control_plane_api/app/skills/file_generation.py

@@ -0,0 +1,94 @@
+"""
+File Generation Skill
+
+Provides file generation capabilities for various formats (JSON, CSV, PDF, TXT).
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from .registry import register_skill
+
+
+class FileGenerationSkill(SkillDefinition):
+    """File generation skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.FILE_GENERATION
+
+    @property
+    def name(self) -> str:
+        return "File Generator"
+
+    @property
+    def description(self) -> str:
+        return "Generate and save files in various formats (JSON, CSV, PDF, TXT)"
+
+    @property
+    def icon(self) -> str:
+        return "FileOutput"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="file_generator",
+                name="File Generator",
+                description="Generate and save files locally: JSON, CSV, PDF, and TXT formats",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="FileOutput",
+                configuration={
+                    "enable_json_generation": True,
+                    "enable_csv_generation": True,
+                    "enable_pdf_generation": True,
+                    "enable_txt_generation": True,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="file_generator_data_only",
+                name="File Generator - Data Only",
+                description="Generate data files only (JSON, CSV) without document formats",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FileText",
+                configuration={
+                    "enable_json_generation": True,
+                    "enable_csv_generation": True,
+                    "enable_pdf_generation": False,
+                    "enable_txt_generation": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate file generation configuration"""
+        validated = {
+            "enable_json_generation": config.get("enable_json_generation", True),
+            "enable_csv_generation": config.get("enable_csv_generation", True),
+            "enable_pdf_generation": config.get("enable_pdf_generation", True),
+            "enable_txt_generation": config.get("enable_txt_generation", True),
+        }
+
+        # Add output_directory if specified
+        if "output_directory" in config:
+            validated["output_directory"] = str(config["output_directory"])
+
+        # Add max_file_size if specified (in MB)
+        if "max_file_size" in config:
+            validated["max_file_size"] = min(config.get("max_file_size", 10), 100)  # Max 100MB
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: all formats enabled"""
+        return {
+            "enable_json_generation": True,
+            "enable_csv_generation": True,
+            "enable_pdf_generation": True,
+            "enable_txt_generation": True,
+        }
+
+
+# Auto-register this skill
+register_skill(FileGenerationSkill())

control_plane_api/app/skills/file_system.py

@@ -0,0 +1,110 @@
+"""
+File System Skill
+
+Provides file system access capabilities (read, write, list, search files).
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from .registry import register_skill
+
+
+class FileSystemSkill(SkillDefinition):
+    """File system access skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.FILE_SYSTEM
+
+    @property
+    def name(self) -> str:
+        return "File System"
+
+    @property
+    def description(self) -> str:
+        return "Access and manipulate files and directories on the local file system"
+
+    @property
+    def icon(self) -> str:
+        return "FolderOpen"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="file_system_read_only",
+                name="File System - Read Only",
+                description="Access local file system for reading, listing, and searching files safely",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FolderOpen",
+                configuration={
+                    "enable_save_file": False,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": True,
+                },
+                is_default=False,
+            ),
+            SkillVariant(
+                id="file_system_full_access",
+                name="File System - Full Access",
+                description="Complete file system access: read, write, create, and modify local files",
+                category=SkillCategory.COMMON,
+                badge="Recommended",
+                icon="HardDrive",
+                configuration={
+                    "enable_save_file": True,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": True,
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="file_system_sandboxed",
+                name="File System - Sandboxed",
+                description="Isolated file access limited to /sandbox directory only",
+                category=SkillCategory.SECURITY,
+                badge="Secure",
+                icon="Shield",
+                configuration={
+                    "base_dir": "/sandbox",
+                    "enable_save_file": True,
+                    "enable_read_file": True,
+                    "enable_list_files": True,
+                    "enable_search_files": False,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate file system configuration"""
+        validated = {
+            "enable_save_file": config.get("enable_save_file", False),
+            "enable_read_file": config.get("enable_read_file", True),
+            "enable_list_files": config.get("enable_list_files", True),
+            "enable_search_files": config.get("enable_search_files", True),
+        }
+
+        # Add base_dir if specified
+        if "base_dir" in config:
+            validated["base_dir"] = str(config["base_dir"])
+
+        # Add allowed_extensions if specified
+        if "allowed_extensions" in config:
+            validated["allowed_extensions"] = list(config["allowed_extensions"])
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: full access"""
+        return {
+            "enable_save_file": True,
+            "enable_read_file": True,
+            "enable_list_files": True,
+            "enable_search_files": True,
+        }
+
+
+# Auto-register this skill
+register_skill(FileSystemSkill())

control_plane_api/app/skills/python.py

@@ -0,0 +1,92 @@
+"""
+Python Skill
+
+Provides Python code execution capabilities with configurable restrictions.
+"""
+from typing import Dict, Any, List
+from .base import SkillDefinition, SkillType, SkillCategory, SkillVariant
+from .registry import register_skill
+
+
+class PythonSkill(SkillDefinition):
+    """Python code execution skill"""
+
+    @property
+    def type(self) -> SkillType:
+        return SkillType.PYTHON
+
+    @property
+    def name(self) -> str:
+        return "Python"
+
+    @property
+    def description(self) -> str:
+        return "Execute Python code locally with configurable import restrictions"
+
+    @property
+    def icon(self) -> str:
+        return "FaPython"
+
+    @property
+    def icon_type(self) -> str:
+        return "react-icon"
+
+    def get_variants(self) -> List[SkillVariant]:
+        return [
+            SkillVariant(
+                id="python_runtime",
+                name="Python Runtime",
+                description="Execute Python code locally with restricted imports for security",
+                category=SkillCategory.COMMON,
+                badge="Safe",
+                icon="FaPython",
+                configuration={
+                    "enable_code_execution": True,
+                    "blocked_imports": ["os", "subprocess", "sys", "socket", "shutil"],
+                },
+                is_default=True,
+            ),
+            SkillVariant(
+                id="python_unrestricted",
+                name="Python - Unrestricted",
+                description="Execute Python code without import restrictions or sandboxing",
+                category=SkillCategory.ADVANCED,
+                badge="Advanced",
+                icon="FaPython",
+                configuration={
+                    "enable_code_execution": True,
+                },
+                is_default=False,
+            ),
+        ]
+
+    def validate_configuration(self, config: Dict[str, Any]) -> Dict[str, Any]:
+        """Validate Python configuration"""
+        validated = {
+            "enable_code_execution": config.get("enable_code_execution", True),
+        }
+
+        # Add blocked_imports if specified
+        if "blocked_imports" in config:
+            validated["blocked_imports"] = list(config["blocked_imports"])
+
+        # Add allowed_imports if specified (whitelist mode)
+        if "allowed_imports" in config:
+            validated["allowed_imports"] = list(config["allowed_imports"])
+
+        # Add timeout if specified
+        if "timeout" in config:
+            validated["timeout"] = min(config.get("timeout", 30), 300)  # Max 5 minutes
+
+        return validated
+
+    def get_default_configuration(self) -> Dict[str, Any]:
+        """Default: restricted imports"""
+        return {
+            "enable_code_execution": True,
+            "blocked_imports": ["os", "subprocess", "sys", "socket", "shutil"],
+        }
+
+
+# Auto-register this skill
+register_skill(PythonSkill())

control_plane_api/app/skills/registry.py

@@ -0,0 +1,65 @@
+"""
+Skill Registry
+
+Central registry for all available skills. Skills self-register
+when their modules are imported.
+"""
+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] = {}
+
+    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 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())
+
+
+# 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()