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

gobby/mcp_proxy/tools/orchestration/orchestrate.py

@@ -35,7 +35,9 @@ def register_orchestrator(
 
     async def orchestrate_ready_tasks(
         parent_task_id: str,
-        provider: Literal["claude", "gemini", "codex", "antigravity"] = "gemini",
+        provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ] = "gemini",
         model: str | None = None,
         terminal: str = "auto",
         mode: str = "terminal",
@@ -43,7 +45,10 @@ def register_orchestrator(
         max_concurrent: int = 3,
         parent_session_id: str | None = None,
         project_path: str | None = None,
-        coding_provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        coding_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
         coding_model: str | None = None,
         base_branch: str | None = None,
     ) -> dict[str, Any]:
@@ -652,7 +657,7 @@ def register_orchestrator(
                 },
                 "provider": {
                     "type": "string",
-                    "description": "Fallback LLM provider (claude, gemini, codex, antigravity)",
+                    "description": "Fallback LLM provider (claude, gemini, codex, antigravity, cursor, windsurf, copilot)",
                     "default": "gemini",
                 },
                 "model": {

gobby/mcp_proxy/tools/orchestration/review.py

@@ -30,7 +30,9 @@ def register_reviewer(
 
     async def spawn_review_agent(
         task_id: str,
-        review_provider: Literal["claude", "gemini", "codex", "antigravity"] = "claude",
+        review_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ] = "claude",
         review_model: str | None = "claude-opus-4-5",
         terminal: str = "auto",
         mode: str = "terminal",
@@ -61,7 +63,15 @@ def register_reviewer(
         """
         # Validate mode and review_provider
         allowed_modes = {"terminal", "embedded", "headless"}
-        allowed_providers = {"claude", "gemini", "codex", "antigravity"}
+        allowed_providers = {
+            "claude",
+            "gemini",
+            "codex",
+            "antigravity",
+            "cursor",
+            "windsurf",
+            "copilot",
+        }
 
         mode_lower = mode.lower() if mode else "terminal"
         if mode_lower not in allowed_modes:
@@ -314,7 +324,7 @@ def register_reviewer(
                 },
                 "review_provider": {
                     "type": "string",
-                    "description": "LLM provider for review (claude, gemini, codex, antigravity)",
+                    "description": "LLM provider for review (claude, gemini, codex, antigravity, cursor, windsurf, copilot)",
                     "default": "claude",
                 },
                 "review_model": {
@@ -350,7 +360,10 @@ def register_reviewer(
     async def process_completed_agents(
         parent_session_id: str,
         spawn_reviews: bool = True,
-        review_provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        review_provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
         review_model: str | None = None,
         terminal: str = "auto",
         mode: str = "terminal",

gobby/mcp_proxy/tools/orchestration/wait.py

@@ -62,7 +62,7 @@ def register_wait(
 
         # Consider task complete if status is "closed" or "review"
         # (review tasks have completed their work, just awaiting human approval)
-        is_complete = task.status in ("closed", "review")
+        is_complete = task.status in ("closed", "needs_review")
         return is_complete, task_info
 
     async def wait_for_task(
@@ -73,7 +73,7 @@ def register_wait(
         """
         Wait for a single task to complete.
 
-        Blocks until the task reaches "closed" or "review" status, or timeout expires.
+        Blocks until the task reaches "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_id: Task reference (#N, N, path, or UUID)
@@ -170,7 +170,7 @@ def register_wait(
         name="wait_for_task",
         description=(
             "Wait for a single task to complete. "
-            "Blocks until task reaches 'closed' or 'review' status, or timeout expires."
+            "Blocks until task reaches 'closed' or 'needs_review' status, or timeout expires."
         ),
         input_schema={
             "type": "object",
@@ -201,7 +201,7 @@ def register_wait(
         """
         Wait for any one of multiple tasks to complete.
 
-        Blocks until at least one task reaches "closed" or "review" status, or timeout expires.
+        Blocks until at least one task reaches "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_ids: List of task references (#N, N, path, or UUID)
@@ -290,7 +290,7 @@ def register_wait(
         name="wait_for_any_task",
         description=(
             "Wait for any one of multiple tasks to complete. "
-            "Returns as soon as the first task reaches 'closed' or 'review' status."
+            "Returns as soon as the first task reaches 'closed' or 'needs_review' status."
         ),
         input_schema={
             "type": "object",
@@ -322,7 +322,7 @@ def register_wait(
         """
         Wait for all tasks to complete.
 
-        Blocks until all tasks reach "closed" or "review" status, or timeout expires.
+        Blocks until all tasks reach "closed" or "needs_review" status, or timeout expires.
 
         Args:
             task_ids: List of task references (#N, N, path, or UUID)
@@ -442,7 +442,7 @@ def register_wait(
         name="wait_for_all_tasks",
         description=(
             "Wait for all tasks to complete. "
-            "Blocks until all tasks reach 'closed' or 'review' status, or timeout expires."
+            "Blocks until all tasks reach 'closed' or 'needs_review' status, or timeout expires."
         ),
         input_schema={
             "type": "object",

gobby/mcp_proxy/tools/pipelines/__init__.py

@@ -0,0 +1,254 @@
+"""
+Internal MCP tools for Gobby Pipeline System.
+
+Exposes functionality for:
+- list_pipelines: Discover available pipeline definitions
+- Dynamic pipeline tools: Pipelines with expose_as_tool=True are exposed as MCP tools
+
+These tools are registered with the InternalToolRegistry and accessed
+via the downstream proxy pattern (call_tool, list_tools, get_tool_schema).
+"""
+
+import logging
+from typing import Any
+
+from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.mcp_proxy.tools.pipelines._discovery import list_pipelines
+from gobby.mcp_proxy.tools.pipelines._execution import (
+    approve_pipeline,
+    get_pipeline_status,
+    reject_pipeline,
+    run_pipeline,
+)
+
+logger = logging.getLogger(__name__)
+
+__all__ = [
+    "create_pipelines_registry",
+]
+
+
+def create_pipelines_registry(
+    loader: Any | None = None,
+    executor: Any | None = None,
+    execution_manager: Any | None = None,
+) -> InternalToolRegistry:
+    """
+    Create a pipeline tool registry with all pipeline-related tools.
+
+    Args:
+        loader: WorkflowLoader instance for discovering pipelines
+        executor: PipelineExecutor instance for running pipelines
+        execution_manager: LocalPipelineExecutionManager for tracking executions
+
+    Returns:
+        InternalToolRegistry with pipeline tools registered
+    """
+    _loader = loader
+    _executor = executor
+    _execution_manager = execution_manager
+
+    registry = InternalToolRegistry(
+        name="gobby-pipelines",
+        description="Pipeline management - list, run, and monitor pipeline executions",
+    )
+
+    # Register dynamic tools for pipelines with expose_as_tool=True
+    _register_exposed_pipeline_tools(registry, _loader, _executor)
+
+    @registry.tool(
+        name="list_pipelines",
+        description="List available pipeline definitions from project and global directories.",
+    )
+    def _list_pipelines(
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        return list_pipelines(_loader, project_path)
+
+    @registry.tool(
+        name="run_pipeline",
+        description="Run a pipeline by name with given inputs.",
+    )
+    async def _run_pipeline(
+        name: str,
+        inputs: dict[str, Any] | None = None,
+        project_id: str | None = None,
+    ) -> dict[str, Any]:
+        return await run_pipeline(
+            loader=_loader,
+            executor=_executor,
+            name=name,
+            inputs=inputs or {},
+            project_id=project_id or "",
+        )
+
+    @registry.tool(
+        name="approve_pipeline",
+        description="Approve a pipeline execution that is waiting for approval.",
+    )
+    async def _approve_pipeline(
+        token: str,
+        approved_by: str | None = None,
+    ) -> dict[str, Any]:
+        return await approve_pipeline(
+            executor=_executor,
+            token=token,
+            approved_by=approved_by,
+        )
+
+    @registry.tool(
+        name="reject_pipeline",
+        description="Reject a pipeline execution that is waiting for approval.",
+    )
+    async def _reject_pipeline(
+        token: str,
+        rejected_by: str | None = None,
+    ) -> dict[str, Any]:
+        return await reject_pipeline(
+            executor=_executor,
+            token=token,
+            rejected_by=rejected_by,
+        )
+
+    @registry.tool(
+        name="get_pipeline_status",
+        description="Get the status of a pipeline execution including step details.",
+    )
+    def _get_pipeline_status(
+        execution_id: str,
+    ) -> dict[str, Any]:
+        return get_pipeline_status(
+            execution_manager=_execution_manager,
+            execution_id=execution_id,
+        )
+
+    return registry
+
+
+def _register_exposed_pipeline_tools(
+    registry: InternalToolRegistry,
+    loader: Any | None,
+    executor: Any | None,
+) -> None:
+    """
+    Register dynamic tools for pipelines with expose_as_tool=True.
+
+    Each exposed pipeline becomes an MCP tool named "pipeline:<pipeline_name>".
+
+    Args:
+        registry: The registry to add tools to
+        loader: WorkflowLoader for discovering pipelines
+        executor: PipelineExecutor for running pipelines
+    """
+    if loader is None:
+        logger.debug("Skipping dynamic pipeline tools: no loader")
+        return
+
+    try:
+        discovered = loader.discover_pipeline_workflows()
+    except Exception:
+        logger.warning("Failed to discover pipelines for dynamic tools", exc_info=True)
+        return
+
+    for workflow in discovered:
+        pipeline = workflow.definition
+
+        # Only expose pipelines with expose_as_tool=True
+        if not getattr(pipeline, "expose_as_tool", False):
+            continue
+
+        _create_pipeline_tool(registry, pipeline, loader, executor)
+
+
+def _create_pipeline_tool(
+    registry: InternalToolRegistry,
+    pipeline: Any,
+    loader: Any,
+    executor: Any | None,
+) -> None:
+    """
+    Create a dynamic tool for a single pipeline.
+
+    Args:
+        registry: The registry to add the tool to
+        pipeline: The PipelineDefinition to expose
+        loader: WorkflowLoader for loading pipelines
+        executor: PipelineExecutor for running pipelines
+    """
+    tool_name = f"pipeline:{pipeline.name}"
+    description = pipeline.description or f"Run the {pipeline.name} pipeline"
+
+    # Build input schema from pipeline inputs
+    input_schema = _build_input_schema(pipeline)
+
+    # Create closure to capture pipeline name
+    pipeline_name = pipeline.name
+
+    async def _execute_pipeline(**kwargs: Any) -> dict[str, Any]:
+        return await run_pipeline(
+            loader=loader,
+            executor=executor,
+            name=pipeline_name,
+            inputs=kwargs,
+            project_id="",
+        )
+
+    # Register the tool with the schema
+    registry.register(
+        name=tool_name,
+        description=description,
+        func=_execute_pipeline,
+        input_schema=input_schema,
+    )
+
+    logger.debug(f"Registered dynamic pipeline tool: {tool_name}")
+
+
+def _build_input_schema(pipeline: Any) -> dict[str, Any]:
+    """
+    Build JSON Schema for pipeline inputs.
+
+    Args:
+        pipeline: The PipelineDefinition
+
+    Returns:
+        JSON Schema dict for the pipeline's inputs
+    """
+    properties = {}
+    required = []
+
+    for name, input_def in pipeline.inputs.items():
+        if isinstance(input_def, dict):
+            # Input is already a schema-like dict
+            prop = {}
+            if "type" in input_def:
+                prop["type"] = input_def["type"]
+            else:
+                prop["type"] = "string"
+
+            if "description" in input_def:
+                prop["description"] = input_def["description"]
+
+            if "default" in input_def:
+                prop["default"] = input_def["default"]
+            else:
+                # No default means required
+                required.append(name)
+
+            properties[name] = prop
+        else:
+            # Input is a simple default value
+            properties[name] = {
+                "type": "string",
+                "default": input_def,
+            }
+
+    schema: dict[str, Any] = {
+        "type": "object",
+        "properties": properties,
+    }
+
+    if required:
+        schema["required"] = required
+
+    return schema

gobby/mcp_proxy/tools/pipelines/_discovery.py

@@ -0,0 +1,67 @@
+"""Pipeline discovery tools."""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def list_pipelines(
+    loader: Any,
+    project_path: str | None = None,
+) -> dict[str, Any]:
+    """
+    List available pipeline definitions.
+
+    Args:
+        loader: WorkflowLoader instance
+        project_path: Optional project path for project-specific pipelines
+
+    Returns:
+        Dict with success status and list of pipeline info
+    """
+    if not loader:
+        return {
+            "success": False,
+            "error": "No loader configured",
+            "pipelines": [],
+        }
+
+    try:
+        discovered = loader.discover_pipeline_workflows(project_path=project_path)
+
+        pipelines = []
+        for workflow in discovered:
+            pipeline_info = {
+                "name": workflow.name,
+                "description": workflow.definition.description,
+                "is_project": workflow.is_project,
+                "path": str(workflow.path),
+                "priority": workflow.priority,
+            }
+
+            # Add step count if available
+            if hasattr(workflow.definition, "steps"):
+                pipeline_info["step_count"] = len(workflow.definition.steps)
+
+            pipelines.append(pipeline_info)
+
+        return {
+            "success": True,
+            "pipelines": pipelines,
+            "count": len(pipelines),
+        }
+
+    except (FileNotFoundError, ValueError) as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "pipelines": [],
+        }
+    except Exception:
+        logger.exception("Unexpected error discovering pipelines")
+        return {
+            "success": False,
+            "error": "Internal error during pipeline discovery",
+            "pipelines": [],
+        }