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

gobby/mcp_proxy/tools/pipelines/_execution.py

@@ -0,0 +1,281 @@
+"""Pipeline execution tools."""
+
+import json
+from typing import Any
+
+from gobby.workflows.pipeline_state import ApprovalRequired
+
+
+async def run_pipeline(
+    loader: Any,
+    executor: Any,
+    name: str,
+    inputs: dict[str, Any],
+    project_id: str,
+) -> dict[str, Any]:
+    """
+    Run a pipeline by name.
+
+    Args:
+        loader: WorkflowLoader instance
+        executor: PipelineExecutor instance
+        name: Pipeline name to run
+        inputs: Input values for the pipeline
+        project_id: Project context for the execution
+
+    Returns:
+        Dict with success status, execution status, and outputs or approval info
+    """
+    if not executor:
+        return {
+            "success": False,
+            "error": "No executor configured",
+        }
+
+    if not loader:
+        return {
+            "success": False,
+            "error": "No loader configured",
+        }
+
+    # Load the pipeline definition
+    pipeline = loader.load_pipeline(name)
+    if not pipeline:
+        return {
+            "success": False,
+            "error": f"Pipeline '{name}' not found",
+        }
+
+    try:
+        # Execute the pipeline
+        execution = await executor.execute(
+            pipeline=pipeline,
+            inputs=inputs,
+            project_id=project_id,
+        )
+
+        # Parse outputs if available
+        outputs = None
+        if execution.outputs_json:
+            try:
+                outputs = json.loads(execution.outputs_json)
+            except json.JSONDecodeError:
+                outputs = execution.outputs_json
+
+        return {
+            "success": True,
+            "status": execution.status.value,
+            "execution_id": execution.id,
+            "outputs": outputs,
+        }
+
+    except ApprovalRequired as e:
+        # Pipeline paused waiting for approval
+        return {
+            "success": True,
+            "status": "waiting_approval",
+            "execution_id": e.execution_id,
+            "step_id": e.step_id,
+            "token": e.token,
+            "message": e.message,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Execution failed: {e}",
+        }
+
+
+async def approve_pipeline(
+    executor: Any,
+    token: str,
+    approved_by: str | None = None,
+) -> dict[str, Any]:
+    """
+    Approve a pipeline execution waiting for approval.
+
+    Args:
+        executor: PipelineExecutor instance
+        token: Approval token from the waiting execution
+        approved_by: Identifier of who approved (email, user ID, etc.)
+
+    Returns:
+        Dict with success status and execution status
+    """
+    if not executor:
+        return {
+            "success": False,
+            "error": "No executor configured",
+        }
+
+    try:
+        execution = await executor.approve(
+            token=token,
+            approved_by=approved_by,
+        )
+
+        return {
+            "success": True,
+            "status": execution.status.value,
+            "execution_id": execution.id,
+        }
+
+    except ValueError as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Approval failed: {e}",
+        }
+
+
+async def reject_pipeline(
+    executor: Any,
+    token: str,
+    rejected_by: str | None = None,
+) -> dict[str, Any]:
+    """
+    Reject a pipeline execution waiting for approval.
+
+    Args:
+        executor: PipelineExecutor instance
+        token: Approval token from the waiting execution
+        rejected_by: Identifier of who rejected (email, user ID, etc.)
+
+    Returns:
+        Dict with success status and execution status (cancelled)
+    """
+    if not executor:
+        return {
+            "success": False,
+            "error": "No executor configured",
+        }
+
+    try:
+        execution = await executor.reject(
+            token=token,
+            rejected_by=rejected_by,
+        )
+
+        return {
+            "success": True,
+            "status": execution.status.value,
+            "execution_id": execution.id,
+        }
+
+    except ValueError as e:
+        return {
+            "success": False,
+            "error": str(e),
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Rejection failed: {e}",
+        }
+
+
+def get_pipeline_status(
+    execution_manager: Any,
+    execution_id: str,
+) -> dict[str, Any]:
+    """
+    Get the status of a pipeline execution.
+
+    Args:
+        execution_manager: LocalPipelineExecutionManager instance
+        execution_id: Execution ID to query
+
+    Returns:
+        Dict with execution details and step statuses
+    """
+    if not execution_manager:
+        return {
+            "success": False,
+            "error": "No execution manager configured",
+        }
+
+    try:
+        execution = execution_manager.get_execution(execution_id)
+        if not execution:
+            return {
+                "success": False,
+                "error": f"Execution '{execution_id}' not found",
+            }
+
+        # Get step executions
+        steps = execution_manager.get_steps_for_execution(execution_id)
+
+        # Parse inputs if available
+        inputs = None
+        if execution.inputs_json:
+            try:
+                inputs = json.loads(execution.inputs_json)
+            except json.JSONDecodeError:
+                inputs = execution.inputs_json
+
+        # Parse outputs if available
+        outputs = None
+        if execution.outputs_json:
+            try:
+                outputs = json.loads(execution.outputs_json)
+            except json.JSONDecodeError:
+                outputs = execution.outputs_json
+
+        # Build execution dict
+        execution_dict = {
+            "id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "project_id": execution.project_id,
+            "status": execution.status.value,
+            "inputs": inputs,
+            "outputs": outputs,
+            "created_at": execution.created_at,
+            "updated_at": execution.updated_at,
+            "completed_at": execution.completed_at,
+            "resume_token": execution.resume_token,
+            "session_id": execution.session_id,
+        }
+
+        # Build steps list
+        steps_list = []
+        for step in steps:
+            step_output = None
+            if step.output_json:
+                try:
+                    step_output = json.loads(step.output_json)
+                except json.JSONDecodeError:
+                    step_output = step.output_json
+
+            steps_list.append(
+                {
+                    "id": step.id,
+                    "step_id": step.step_id,
+                    "status": step.status.value,
+                    "started_at": step.started_at,
+                    "completed_at": step.completed_at,
+                    "output": step_output,
+                    "error": step.error,
+                    "approval_token": step.approval_token,
+                    "approved_by": step.approved_by,
+                    "approved_at": step.approved_at,
+                }
+            )
+
+        return {
+            "success": True,
+            "execution": execution_dict,
+            "steps": steps_list,
+        }
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Failed to get status: {e}",
+        }

gobby/mcp_proxy/tools/sessions/_crud.py

@@ -75,7 +75,7 @@ def register_crud_tools(
         description="""Get YOUR current session ID - the CORRECT way to look up your session.
 
 Use this when session_id wasn't in your injected context. Pass your external_id
-(from transcript path or GOBBY_SESSION_ID env) and source (claude, gemini, codex).
+(from transcript path or GOBBY_SESSION_ID env) and source (claude, gemini, codex, cursor, windsurf, copilot).
 
 DO NOT use list_sessions to find your session - it won't work with multiple active sessions.""",
     )
@@ -87,12 +87,12 @@ DO NOT use list_sessions to find your session - it won't work with multiple acti
         Look up your internal session_id from external_id and source.
 
         The agent passes external_id (from injected context or GOBBY_SESSION_ID env var)
-        and source (claude, gemini, codex). project_id and machine_id are
+        and source (claude, gemini, codex, cursor, windsurf, copilot). project_id and machine_id are
         auto-resolved from config files.
 
         Args:
             external_id: Your CLI's session ID (from context or GOBBY_SESSION_ID env)
-            source: CLI source - "claude", "gemini", or "codex"
+            source: CLI source - "claude", "gemini", "codex", "cursor", "windsurf", or "copilot"
 
         Returns:
             session_id: Internal Gobby session ID (use for parent_session_id, etc.)
@@ -240,7 +240,7 @@ This tool is for browsing/listing sessions, not for self-identification.""",
 
         # Count by source
         by_source: dict[str, int] = {}
-        for src in ["claude_code", "gemini", "codex"]:
+        for src in ["claude", "gemini", "codex", "cursor", "windsurf", "copilot"]:
             count = session_manager.count(project_id=project_id, source=src)
             if count > 0:
                 by_source[src] = count

gobby/mcp_proxy/tools/sessions/_handoff.py

@@ -414,7 +414,7 @@ Args:
         Args:
             session_id: Session reference - supports #N, N (seq_num), UUID, or prefix (optional)
             project_id: Project ID to find parent session in (optional)
-            source: Filter by CLI source - claude_code, gemini, codex (optional)
+            source: Filter by CLI source - claude, gemini, codex, cursor, windsurf, copilot (optional)
             link_child_session_id: Session to link as child - supports #N, N, UUID, or prefix (optional)
 
         Returns:

gobby/mcp_proxy/tools/skills/__init__.py

@@ -20,6 +20,7 @@ from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.skills.hubs.manager import HubManager
 from gobby.skills.loader import SkillLoader, SkillLoadError
 from gobby.skills.search import SearchFilters, SkillSearch
 from gobby.skills.updater import SkillUpdater
@@ -45,6 +46,7 @@ class SkillsToolRegistry(InternalToolRegistry):
 def create_skills_registry(
     db: DatabaseProtocol,
     project_id: str | None = None,
+    hub_manager: HubManager | None = None,
 ) -> SkillsToolRegistry:
     """
     Create a skills management tool registry.
@@ -52,13 +54,14 @@ def create_skills_registry(
     Args:
         db: Database connection for storage
         project_id: Optional default project scope for skill operations
+        hub_manager: Optional HubManager for hub operations (list_hubs, search_hub)
 
     Returns:
         SkillsToolRegistry with skill management tools registered
     """
     registry = SkillsToolRegistry(
         name="gobby-skills",
-        description="Skill management - list_skills, get_skill, search_skills, install_skill, update_skill, remove_skill",
+        description="Skill management - list_skills, get_skill, search_skills, install_skill, update_skill, remove_skill, list_hubs, search_hub",
     )
 
     # Initialize change notifier and storage
@@ -485,40 +488,87 @@ def create_skills_registry(
             source = source.strip()
 
             # Determine source type and load skill
+            from gobby.skills.parser import ParsedSkill
             from gobby.storage.skills import SkillSourceType
 
-            parsed_skill = None
+            parsed_skill: ParsedSkill | list[ParsedSkill] | None = None
             source_type: SkillSourceType | None = None
 
-            # Check if it's a GitHub URL/reference
-            # Pattern for owner/repo format (e.g., "anthropic/claude-code")
-            # Must match owner/repo pattern without path traversal or absolute paths
-            github_owner_repo_pattern = re.compile(
-                r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+(/[A-Za-z0-9_./-]*)?$"
-            )
+            # Check for hub:slug syntax (e.g., "clawdhub:commit-message")
+            # Must have exactly one colon, not be a URL, and the hub part must be alphanumeric
+            hub_pattern = re.compile(r"^([A-Za-z0-9_-]+):([A-Za-z0-9_-]+)$")
+            hub_match = hub_pattern.match(source)
 
-            # Explicit GitHub references (always treated as GitHub, no filesystem check)
-            is_explicit_github = (
-                source.startswith("github:")
-                or source.startswith("https://github.com/")
-                or source.startswith("http://github.com/")
-            )
+            if hub_match and not source.startswith("http"):
+                # Hub reference: hub_name:skill_slug
+                hub_name, skill_slug = hub_match.groups()
 
-            # For implicit owner/repo patterns, check local filesystem first
-            is_implicit_github_pattern = (
-                not is_explicit_github
-                and github_owner_repo_pattern.match(source)
-                and not source.startswith("/")
-                and ".." not in source  # Reject path traversal
-            )
+                if hub_manager is None:
+                    return {
+                        "success": False,
+                        "error": "No hub manager configured. Add hubs to config to enable hub installs.",
+                    }
 
-            # Determine if this is a GitHub reference:
-            # - Explicit refs are always GitHub
-            # - Implicit patterns are GitHub only if local path doesn't exist
-            is_github_ref = is_explicit_github or (
-                is_implicit_github_pattern and not Path(source).exists()
-            )
-            if is_github_ref:
+                if not hub_manager.has_hub(hub_name):
+                    return {
+                        "success": False,
+                        "error": f"Unknown hub: {hub_name}. Use list_hubs to see available hubs.",
+                    }
+
+                try:
+                    # Get the provider and download the skill
+                    provider = hub_manager.get_provider(hub_name)
+                    download_result = await provider.download_skill(skill_slug)
+
+                    if not download_result.success or not download_result.path:
+                        return {
+                            "success": False,
+                            "error": f"Failed to download from hub: {download_result.error or 'Unknown error'}",
+                        }
+
+                    # Load the skill from the downloaded path
+                    skill_path = Path(download_result.path)
+                    parsed_skill = loader.load_skill(skill_path)
+                    source_type = "hub"
+
+                except Exception as e:
+                    return {
+                        "success": False,
+                        "error": f"Failed to install from hub {hub_name}: {e}",
+                    }
+
+            # Check if it's a GitHub URL/reference (only if not already parsed from hub)
+            is_github_ref = False
+            if parsed_skill is None:
+                # Pattern for owner/repo format (e.g., "anthropic/claude-code")
+                # Must match owner/repo pattern without path traversal or absolute paths
+                github_owner_repo_pattern = re.compile(
+                    r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+(/[A-Za-z0-9_./-]*)?$"
+                )
+
+                # Explicit GitHub references (always treated as GitHub, no filesystem check)
+                is_explicit_github = (
+                    source.startswith("github:")
+                    or source.startswith("https://github.com/")
+                    or source.startswith("http://github.com/")
+                )
+
+                # For implicit owner/repo patterns, check local filesystem first
+                is_implicit_github_pattern = (
+                    not is_explicit_github
+                    and github_owner_repo_pattern.match(source)
+                    and not source.startswith("/")
+                    and ".." not in source  # Reject path traversal
+                )
+
+                # Determine if this is a GitHub reference:
+                # - Explicit refs are always GitHub
+                # - Implicit patterns are GitHub only if local path doesn't exist
+                is_github_ref = is_explicit_github or bool(
+                    is_implicit_github_pattern and not Path(source).exists()
+                )
+
+            if parsed_skill is None and is_github_ref:
                 # GitHub URL
                 try:
                     parsed_skill = loader.load_from_github(source)
@@ -530,7 +580,7 @@ def create_skills_registry(
                     }
 
             # Check if it's a ZIP file
-            elif source.endswith(".zip"):
+            elif parsed_skill is None and source.endswith(".zip"):
                 zip_path = Path(source)
                 if not zip_path.exists():
                     return {
@@ -547,7 +597,7 @@ def create_skills_registry(
                     }
 
             # Assume it's a local path
-            else:
+            elif parsed_skill is None:
                 local_path = Path(source)
                 if not local_path.exists():
                     return {
@@ -613,4 +663,108 @@ def create_skills_registry(
                 "error": str(e),
             }
 
+    # --- list_hubs tool ---
+
+    @registry.tool(
+        name="list_hubs",
+        description="List all configured skill hubs. Returns hub names and types.",
+    )
+    async def list_hubs() -> dict[str, Any]:
+        """
+        List all configured skill hubs.
+
+        Returns hub name, type, and base_url for each configured hub.
+
+        Returns:
+            Dict with success status and list of hub info
+        """
+        try:
+            if hub_manager is None:
+                return {
+                    "success": True,
+                    "count": 0,
+                    "hubs": [],
+                }
+
+            hub_names = hub_manager.list_hubs()
+            hubs_list = []
+
+            for name in hub_names:
+                config = hub_manager.get_config(name)
+                hubs_list.append(
+                    {
+                        "name": name,
+                        "type": config.type,
+                        "base_url": config.base_url,
+                    }
+                )
+
+            return {
+                "success": True,
+                "count": len(hubs_list),
+                "hubs": hubs_list,
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
+    # --- search_hub tool ---
+
+    @registry.tool(
+        name="search_hub",
+        description="Search for skills across configured hubs. Returns ranked results from all or specific hubs.",
+    )
+    async def search_hub(
+        query: str,
+        hub_name: str | None = None,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        """
+        Search for skills across configured hubs.
+
+        Args:
+            query: Search query (required, non-empty)
+            hub_name: Optional specific hub to search (None for all hubs)
+            limit: Maximum results per hub (default 20)
+
+        Returns:
+            Dict with success status and search results
+        """
+        try:
+            # Validate query
+            if not query or not query.strip():
+                return {
+                    "success": False,
+                    "error": "Query is required and cannot be empty",
+                }
+
+            if hub_manager is None:
+                return {
+                    "success": False,
+                    "error": "No hub manager configured. Add hubs to config to enable hub search.",
+                }
+
+            # Build hub filter
+            hub_names_filter = [hub_name] if hub_name else None
+
+            # Perform search
+            results = await hub_manager.search_all(
+                query=query.strip(),
+                limit=limit,
+                hub_names=hub_names_filter,
+            )
+
+            return {
+                "success": True,
+                "count": len(results),
+                "results": results,
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+            }
+
     return registry