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

gobby/workflows/pipeline_state.py

@@ -0,0 +1,172 @@
+"""Pipeline execution state models.
+
+This module defines the runtime state models for pipeline executions,
+including execution status tracking, step execution records, and the
+ApprovalRequired exception for approval gates.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any
+
+
+class ExecutionStatus(Enum):
+    """Status values for pipeline executions."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    WAITING_APPROVAL = "waiting_approval"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class StepStatus(Enum):
+    """Status values for individual step executions."""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    WAITING_APPROVAL = "waiting_approval"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    SKIPPED = "skipped"
+
+
+@dataclass
+class PipelineExecution:
+    """Execution state for a pipeline.
+
+    Tracks the overall execution of a pipeline including inputs, outputs,
+    status, and optional resume token for approval gates.
+    """
+
+    id: str  # Format: pe-{12hex}
+    pipeline_name: str
+    project_id: str
+    status: ExecutionStatus
+    created_at: str
+    updated_at: str
+    inputs_json: str | None = None
+    outputs_json: str | None = None
+    completed_at: str | None = None
+    resume_token: str | None = None  # Token for resuming after approval
+    session_id: str | None = None  # Session that triggered execution
+    parent_execution_id: str | None = None  # For nested pipeline invocations
+
+    @classmethod
+    def from_row(cls, row: Any) -> PipelineExecution:
+        """Create PipelineExecution from database row."""
+        return cls(
+            id=row["id"],
+            pipeline_name=row["pipeline_name"],
+            project_id=row["project_id"],
+            status=ExecutionStatus(row["status"]),
+            inputs_json=row["inputs_json"],
+            outputs_json=row["outputs_json"],
+            created_at=row["created_at"],
+            updated_at=row["updated_at"],
+            completed_at=row["completed_at"],
+            resume_token=row["resume_token"],
+            session_id=row["session_id"],
+            parent_execution_id=row["parent_execution_id"],
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for API responses."""
+        return {
+            "id": self.id,
+            "pipeline_name": self.pipeline_name,
+            "project_id": self.project_id,
+            "status": self.status.value,
+            "inputs_json": self.inputs_json,
+            "outputs_json": self.outputs_json,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "completed_at": self.completed_at,
+            "resume_token": self.resume_token,
+            "session_id": self.session_id,
+            "parent_execution_id": self.parent_execution_id,
+        }
+
+
+@dataclass
+class StepExecution:
+    """Execution state for a single pipeline step.
+
+    Tracks individual step execution including input/output, timing,
+    errors, and approval state.
+    """
+
+    id: int  # Auto-increment integer
+    execution_id: str  # Parent pipeline execution ID
+    step_id: str  # Step ID from pipeline definition
+    status: StepStatus
+    started_at: str | None = None
+    completed_at: str | None = None
+    input_json: str | None = None
+    output_json: str | None = None
+    error: str | None = None
+    approval_token: str | None = None  # Unique token for this step's approval
+    approved_by: str | None = None  # Who approved (email, user ID, etc.)
+    approved_at: str | None = None
+
+    @classmethod
+    def from_row(cls, row: Any) -> StepExecution:
+        """Create StepExecution from database row."""
+        return cls(
+            id=row["id"],
+            execution_id=row["execution_id"],
+            step_id=row["step_id"],
+            status=StepStatus(row["status"]),
+            started_at=row["started_at"],
+            completed_at=row["completed_at"],
+            input_json=row["input_json"],
+            output_json=row["output_json"],
+            error=row["error"],
+            approval_token=row["approval_token"],
+            approved_by=row["approved_by"],
+            approved_at=row["approved_at"],
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert to dictionary for API responses."""
+        return {
+            "id": self.id,
+            "execution_id": self.execution_id,
+            "step_id": self.step_id,
+            "status": self.status.value,
+            "started_at": self.started_at,
+            "completed_at": self.completed_at,
+            "input_json": self.input_json,
+            "output_json": self.output_json,
+            "error": self.error,
+            "approval_token": self.approval_token,
+            "approved_by": self.approved_by,
+            "approved_at": self.approved_at,
+        }
+
+
+class ApprovalRequired(Exception):
+    """Exception raised when a pipeline step requires approval.
+
+    This exception is raised during pipeline execution when a step
+    has an approval gate. The execution pauses and waits for external
+    approval via the resume token.
+    """
+
+    def __init__(
+        self,
+        execution_id: str,
+        step_id: str,
+        token: str,
+        message: str,
+    ) -> None:
+        self.execution_id = execution_id
+        self.step_id = step_id
+        self.token = token
+        self.message = message
+        super().__init__(
+            f"Approval required for step '{step_id}' in execution '{execution_id}': {message}"
+        )

gobby/workflows/pipeline_webhooks.py

@@ -0,0 +1,206 @@
+"""Pipeline webhook notifier for sending HTTP notifications.
+
+This module provides the WebhookNotifier class for sending webhook
+notifications during pipeline execution events (approval pending,
+completion, failure).
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+if TYPE_CHECKING:
+    from gobby.workflows.definitions import PipelineDefinition
+    from gobby.workflows.pipeline_state import PipelineExecution
+
+logger = logging.getLogger(__name__)
+
+
+class WebhookNotifier:
+    """Sends webhook notifications for pipeline execution events.
+
+    Handles approval pending, completion, and failure notifications
+    with environment variable expansion in headers.
+    """
+
+    def __init__(self, base_url: str = "http://localhost:7778"):
+        """Initialize the webhook notifier.
+
+        Args:
+            base_url: Base URL for generating approve/reject URLs.
+                     Defaults to localhost Gobby daemon URL.
+        """
+        self.base_url = base_url.rstrip("/")
+
+    async def notify_approval_pending(
+        self,
+        execution: PipelineExecution,
+        pipeline: PipelineDefinition,
+        step_id: str,
+        token: str,
+        message: str,
+    ) -> None:
+        """Send notification when approval is required.
+
+        Args:
+            execution: The pipeline execution state
+            pipeline: The pipeline definition (contains webhook config)
+            step_id: The step ID requiring approval
+            token: The approval token for approve/reject URLs
+            message: The approval message to display
+        """
+        if not pipeline.webhooks or not pipeline.webhooks.on_approval_pending:
+            logger.debug(f"No on_approval_pending webhook configured for {pipeline.name}")
+            return
+
+        endpoint = pipeline.webhooks.on_approval_pending
+        payload = {
+            "execution_id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "step_id": step_id,
+            "token": token,
+            "message": message,
+            "approve_url": f"{self.base_url}/api/pipelines/approve/{token}",
+            "reject_url": f"{self.base_url}/api/pipelines/reject/{token}",
+            "status": execution.status.value,
+        }
+
+        await self._send_webhook(endpoint.url, endpoint.method, endpoint.headers, payload)
+
+    async def notify_complete(
+        self,
+        execution: PipelineExecution,
+        pipeline: PipelineDefinition,
+    ) -> None:
+        """Send notification when pipeline completes successfully.
+
+        Args:
+            execution: The pipeline execution state
+            pipeline: The pipeline definition (contains webhook config)
+        """
+        if not pipeline.webhooks or not pipeline.webhooks.on_complete:
+            logger.debug(f"No on_complete webhook configured for {pipeline.name}")
+            return
+
+        endpoint = pipeline.webhooks.on_complete
+
+        # Parse outputs JSON if present
+        outputs = None
+        if execution.outputs_json:
+            try:
+                outputs = json.loads(execution.outputs_json)
+            except json.JSONDecodeError:
+                outputs = execution.outputs_json
+
+        payload = {
+            "execution_id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "status": execution.status.value,
+            "outputs": outputs,
+            "completed_at": execution.completed_at,
+        }
+
+        await self._send_webhook(endpoint.url, endpoint.method, endpoint.headers, payload)
+
+    async def notify_failure(
+        self,
+        execution: PipelineExecution,
+        pipeline: PipelineDefinition,
+        error: str,
+    ) -> None:
+        """Send notification when pipeline fails.
+
+        Args:
+            execution: The pipeline execution state
+            pipeline: The pipeline definition (contains webhook config)
+            error: The error message describing the failure
+        """
+        if not pipeline.webhooks or not pipeline.webhooks.on_failure:
+            logger.debug(f"No on_failure webhook configured for {pipeline.name}")
+            return
+
+        endpoint = pipeline.webhooks.on_failure
+        payload = {
+            "execution_id": execution.id,
+            "pipeline_name": execution.pipeline_name,
+            "status": execution.status.value,
+            "error": error,
+        }
+
+        await self._send_webhook(endpoint.url, endpoint.method, endpoint.headers, payload)
+
+    async def _send_webhook(
+        self,
+        url: str,
+        method: str,
+        headers: dict[str, str],
+        payload: dict[str, Any],
+    ) -> None:
+        """Send HTTP webhook request.
+
+        Args:
+            url: Target URL
+            method: HTTP method (POST, PUT, etc.)
+            headers: Request headers (supports ${VAR} expansion)
+            payload: JSON payload to send
+        """
+        # Expand environment variables in headers
+        expanded_headers = self._expand_env_vars(headers)
+
+        try:
+            async with httpx.AsyncClient() as client:
+                if method.upper() == "POST":
+                    response = await client.post(
+                        url=url,
+                        headers=expanded_headers,
+                        json=payload,
+                        timeout=30.0,
+                    )
+                elif method.upper() == "PUT":
+                    response = await client.put(
+                        url=url,
+                        headers=expanded_headers,
+                        json=payload,
+                        timeout=30.0,
+                    )
+                else:
+                    logger.warning(f"Unsupported webhook method: {method}")
+                    return
+
+                if response.status_code >= 400:
+                    logger.error(
+                        f"Webhook request failed: {response.status_code} - {response.text}"
+                    )
+                else:
+                    logger.debug(f"Webhook sent successfully to {url}")
+
+        except Exception as e:
+            logger.error(f"Failed to send webhook to {url}: {e}")
+
+    def _expand_env_vars(self, headers: dict[str, str]) -> dict[str, str]:
+        """Expand ${VAR} patterns in header values from environment.
+
+        Args:
+            headers: Header dict with potential ${VAR} patterns
+
+        Returns:
+            New dict with expanded values
+        """
+        result = {}
+        pattern = re.compile(r"\$\{([^}]+)\}")
+
+        for key, value in headers.items():
+
+            def replacer(match: re.Match[str]) -> str:
+                var_name = match.group(1)
+                return os.environ.get(var_name, match.group(0))
+
+            result[key] = pattern.sub(replacer, value)
+
+        return result

gobby/workflows/premature_stop.py

@@ -12,6 +12,7 @@ from types import SimpleNamespace
 from typing import TYPE_CHECKING, Any
 
 from gobby.hooks.events import HookEvent, HookResponse
+from gobby.workflows.definitions import WorkflowDefinition
 
 if TYPE_CHECKING:
     from .evaluator import ConditionEvaluator
@@ -68,6 +69,10 @@ async def check_premature_stop(
         logger.warning(f"Workflow '{state.workflow_name}' not found for premature stop check")
         return None
 
+    # Premature stop handling only applies to WorkflowDefinition, not PipelineDefinition
+    if not isinstance(workflow, WorkflowDefinition):
+        return None
+
     # Check if workflow has exit_condition and on_premature_stop
     if not workflow.exit_condition:
         return None

gobby/worktrees/git.py

@@ -114,6 +114,7 @@ class WorktreeGitManager:
         branch_name: str,
         base_branch: str = "main",
         create_branch: bool = True,
+        use_local: bool = False,
     ) -> GitOperationResult:
         """
         Create a new git worktree.
@@ -123,6 +124,8 @@ class WorktreeGitManager:
             branch_name: Name of the branch for the worktree
             base_branch: Branch to base the new branch on (if create_branch=True)
             create_branch: Whether to create a new branch or use existing
+            use_local: If True, create from local branch ref instead of origin/
+                       This preserves unpushed commits in the worktree.
 
         Returns:
             GitOperationResult with success status and message
@@ -141,28 +144,52 @@ class WorktreeGitManager:
 
         try:
             if create_branch:
-                # Create worktree with new branch based on base_branch
-                # First, fetch to ensure we have latest refs
-                fetch_result = self._run_git(["fetch", "origin", base_branch], timeout=60)
-                if fetch_result.returncode != 0:
-                    return GitOperationResult(
-                        success=False,
-                        message=f"Failed to fetch origin/{base_branch}: {fetch_result.stderr}",
-                        error=fetch_result.stderr,
+                if use_local:
+                    # Create worktree from local branch (preserves unpushed commits)
+                    # Verify local branch exists
+                    verify_result = self._run_git(["rev-parse", "--verify", base_branch], timeout=5)
+                    if verify_result.returncode != 0:
+                        return GitOperationResult(
+                            success=False,
+                            message=f"Local branch '{base_branch}' not found",
+                            error=verify_result.stderr,
+                        )
+
+                    # Create worktree with new branch based on local ref
+                    result = self._run_git(
+                        [
+                            "worktree",
+                            "add",
+                            "-b",
+                            branch_name,
+                            str(worktree_path),
+                            base_branch,  # Local ref, not origin/
+                        ],
+                        timeout=60,
                     )
+                else:
+                    # Create worktree with new branch based on origin (original behavior)
+                    # First, fetch to ensure we have latest refs
+                    fetch_result = self._run_git(["fetch", "origin", base_branch], timeout=60)
+                    if fetch_result.returncode != 0:
+                        return GitOperationResult(
+                            success=False,
+                            message=f"Failed to fetch origin/{base_branch}: {fetch_result.stderr}",
+                            error=fetch_result.stderr,
+                        )
 
-                # Create worktree with new branch
-                result = self._run_git(
-                    [
-                        "worktree",
-                        "add",
-                        "-b",
-                        branch_name,
-                        str(worktree_path),
-                        f"origin/{base_branch}",
-                    ],
-                    timeout=60,
-                )
+                    # Create worktree with new branch
+                    result = self._run_git(
+                        [
+                            "worktree",
+                            "add",
+                            "-b",
+                            branch_name,
+                            str(worktree_path),
+                            f"origin/{base_branch}",
+                        ],
+                        timeout=60,
+                    )
             else:
                 # Use existing branch
                 result = self._run_git(
@@ -688,3 +715,91 @@ class WorktreeGitManager:
         # Method 3: Fall back to "main"
         logger.debug("Could not detect default branch, falling back to 'main'")
         return "main"
+
+    def get_current_branch(self) -> str | None:
+        """
+        Get the current branch of the repository.
+
+        Returns:
+            Branch name, or None if in detached HEAD state
+        """
+        try:
+            result = self._run_git(
+                ["branch", "--show-current"],
+                timeout=5,
+            )
+            if result.returncode == 0:
+                branch = result.stdout.strip()
+                return branch if branch else None
+            return None
+        except Exception:
+            return None
+
+    def has_unpushed_commits(self, branch: str | None = None) -> tuple[bool, int]:
+        """
+        Check if the branch has commits not pushed to origin.
+
+        Args:
+            branch: Branch to check (defaults to current branch)
+
+        Returns:
+            Tuple of (has_unpushed, count) where:
+            - has_unpushed: True if there are unpushed commits
+            - count: Number of unpushed commits (0 if none or error)
+        """
+        if branch is None:
+            branch = self.get_current_branch()
+        if not branch:
+            return False, 0
+
+        try:
+            # Check if remote tracking branch exists
+            result = self._run_git(
+                ["rev-parse", "--verify", f"origin/{branch}"],
+                timeout=5,
+            )
+            if result.returncode != 0:
+                # No remote tracking branch - all local commits are "unpushed"
+                # Count commits on the branch
+                count_result = self._run_git(
+                    ["rev-list", "--count", branch],
+                    timeout=5,
+                )
+                if count_result.returncode == 0:
+                    count = int(count_result.stdout.strip())
+                    return count > 0, count
+                return True, 0
+
+            # Count commits ahead of origin
+            result = self._run_git(
+                ["rev-list", "--count", f"origin/{branch}..{branch}"],
+                timeout=5,
+            )
+            if result.returncode == 0:
+                count = int(result.stdout.strip())
+                return count > 0, count
+            return False, 0
+        except Exception as e:
+            logger.warning(f"Error checking unpushed commits: {e}")
+            return False, 0
+
+    def get_local_commit(self, branch: str) -> str | None:
+        """
+        Get the commit SHA of a local branch.
+
+        Args:
+            branch: Branch name
+
+        Returns:
+            Commit SHA, or None if branch doesn't exist
+        """
+        try:
+            result = self._run_git(
+                ["rev-parse", branch],
+                timeout=5,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+            return None
+        except Exception:
+            return None