gobby 0.2.5__py3-none-any.whl

gobby/workflows/templates.py

@@ -0,0 +1,52 @@
+import logging
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader, select_autoescape
+
+logger = logging.getLogger(__name__)
+
+
+class TemplateEngine:
+    """
+    Engine for rendering Jinja2 templates in workflows.
+    """
+
+    def __init__(self, template_dirs: list[str] | None = None):
+        if template_dirs:
+            loader = FileSystemLoader(template_dirs)
+        else:
+            loader = None
+
+        self.env = Environment(
+            loader=loader,
+            # Disable autoescape for inline templates (default_for_string=False)
+            # We generate markdown, not HTML - escaping breaks apostrophes etc.
+            autoescape=select_autoescape(["html", "xml"], default_for_string=False),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+    def render(self, template_str: str, context: dict[str, Any]) -> str:
+        """
+        Render a template string with the given context.
+        """
+        try:
+            template = self.env.from_string(template_str)
+            return str(template.render(**context))
+        except Exception as e:
+            logger.error(f"Error rendering template: {e}", exc_info=True)
+            # Fallback to original string or raise?
+            # For workflows, it might be better to fail typically, but let's return error message in string for visibility if strict validation isn't on.
+            # actually, better to raise so the action fails and handles it.
+            raise e
+
+    def render_file(self, template_name: str, context: dict[str, Any]) -> str:
+        """
+        Render a template file with the given context.
+        """
+        try:
+            template = self.env.get_template(template_name)
+            return str(template.render(**context))
+        except Exception as e:
+            logger.error(f"Error rendering template file '{template_name}': {e}", exc_info=True)
+            raise e

gobby/workflows/todo_actions.py

@@ -0,0 +1,84 @@
+"""Todo file workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These functions handle TODO.md file operations.
+"""
+
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def write_todos(
+    todos: list[str],
+    filename: str = "TODO.md",
+    mode: str = "w",
+) -> dict[str, Any]:
+    """Write todos to a file (default TODO.md).
+
+    Args:
+        todos: List of todo strings
+        filename: Output filename (default: TODO.md)
+        mode: "w" to overwrite, "append" to append
+
+    Returns:
+        Dict with todos_written count and file path, or error
+    """
+    try:
+        formatted_todos = [f"- [ ] {todo}" for todo in todos]
+
+        if mode == "append" and os.path.exists(filename):
+            with open(filename, "a") as f:
+                f.write("\n" + "\n".join(formatted_todos) + "\n")
+        else:
+            with open(filename, "w") as f:
+                f.write("# TODOs\n\n" + "\n".join(formatted_todos) + "\n")
+
+        return {"todos_written": len(todos), "file": filename}
+    except Exception as e:
+        logger.error(f"write_todos: Failed: {e}")
+        return {"error": str(e)}
+
+
+def mark_todo_complete(
+    todo_text: str,
+    filename: str = "TODO.md",
+) -> dict[str, Any]:
+    """Mark the first occurrence of a todo as complete in TODO.md.
+
+    Args:
+        todo_text: Text of the todo to mark complete
+        filename: Todo file path (default: TODO.md)
+
+    Returns:
+        Dict with todo_completed boolean and text, or error
+    """
+    if not todo_text:
+        return {"error": "Missing todo_text"}
+
+    if not os.path.exists(filename):
+        return {"error": "File not found"}
+
+    try:
+        with open(filename) as f:
+            lines = f.readlines()
+
+        updated = False
+        new_lines = []
+        for line in lines:
+            if not updated and todo_text in line and "- [ ]" in line:
+                new_lines.append(line.replace("- [ ]", "- [x]"))
+                updated = True
+            else:
+                new_lines.append(line)
+
+        if updated:
+            with open(filename, "w") as f:
+                f.writelines(new_lines)
+
+        return {"todo_completed": updated, "text": todo_text}
+    except Exception as e:
+        logger.error(f"mark_todo_complete: Failed: {e}")
+        return {"error": str(e)}

gobby/workflows/webhook.py

@@ -0,0 +1,223 @@
+"""
+Webhook workflow action models.
+
+Defines the WebhookAction class and related configuration models
+for making HTTP requests from workflows.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+from urllib.parse import urlparse
+
+# Valid HTTP methods for webhook actions
+VALID_METHODS = frozenset({"GET", "POST", "PUT", "PATCH", "DELETE"})
+
+# Default retry status codes (server errors and rate limiting)
+DEFAULT_RETRY_STATUS_CODES = [429, 500, 502, 503, 504]
+
+
+@dataclass
+class RetryConfig:
+    """Configuration for webhook retry behavior."""
+
+    max_attempts: int = 3
+    backoff_seconds: int = 1
+    retry_on_status: list[int] = field(default_factory=lambda: DEFAULT_RETRY_STATUS_CODES.copy())
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> RetryConfig:
+        """Parse RetryConfig from a dict.
+
+        Args:
+            data: Dict with retry configuration fields.
+
+        Returns:
+            RetryConfig instance.
+
+        Raises:
+            ValueError: If max_attempts is outside 1-10 range.
+        """
+        max_attempts = data.get("max_attempts", 3)
+        if not (1 <= max_attempts <= 10):
+            raise ValueError(f"max_attempts must be between 1 and 10, got {max_attempts}")
+
+        backoff_seconds = data.get("backoff_seconds", 1)
+        retry_on_status = data.get("retry_on_status", DEFAULT_RETRY_STATUS_CODES.copy())
+
+        return cls(
+            max_attempts=max_attempts,
+            backoff_seconds=backoff_seconds,
+            retry_on_status=list(retry_on_status),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict."""
+        return {
+            "max_attempts": self.max_attempts,
+            "backoff_seconds": self.backoff_seconds,
+            "retry_on_status": self.retry_on_status,
+        }
+
+
+@dataclass
+class CaptureConfig:
+    """Configuration for capturing webhook response data."""
+
+    status_var: str | None = None
+    body_var: str | None = None
+    headers_var: str | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CaptureConfig:
+        """Parse CaptureConfig from a dict.
+
+        Args:
+            data: Dict with capture configuration fields.
+
+        Returns:
+            CaptureConfig instance.
+        """
+        return cls(
+            status_var=data.get("status_var"),
+            body_var=data.get("body_var"),
+            headers_var=data.get("headers_var"),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict."""
+        result: dict[str, Any] = {}
+        if self.status_var:
+            result["status_var"] = self.status_var
+        if self.body_var:
+            result["body_var"] = self.body_var
+        if self.headers_var:
+            result["headers_var"] = self.headers_var
+        return result
+
+
+@dataclass
+class WebhookAction:
+    """Webhook action definition for workflows.
+
+    Represents an HTTP request that can be made during workflow execution.
+    Either `url` or `webhook_id` must be provided, but not both.
+    """
+
+    url: str | None = None
+    webhook_id: str | None = None
+    method: str = "POST"
+    headers: dict[str, str] = field(default_factory=dict)
+    payload: str | dict[str, Any] | None = None
+    timeout: int = 30
+    retry: RetryConfig | None = None
+    on_success: str | None = None
+    on_failure: str | None = None
+    capture_response: CaptureConfig | None = None
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> WebhookAction:
+        """Parse WebhookAction from a dict (e.g., from YAML workflow).
+
+        Args:
+            data: Dict with webhook action fields.
+
+        Returns:
+            WebhookAction instance.
+
+        Raises:
+            ValueError: If validation fails (missing url/webhook_id, invalid method, etc.).
+        """
+        url = data.get("url")
+        webhook_id = data.get("webhook_id")
+
+        # Validate url/webhook_id exclusivity
+        if url and webhook_id:
+            raise ValueError(
+                "url and webhook_id are mutually exclusive - provide only one, not both"
+            )
+        if not url and not webhook_id:
+            raise ValueError("Either url or webhook_id is required")
+
+        # Validate URL scheme if url is provided
+        if url:
+            cls._validate_url(url)
+
+        # Validate method
+        method = data.get("method", "POST").upper()
+        if method not in VALID_METHODS:
+            raise ValueError(
+                f"Invalid HTTP method '{method}'. Must be one of: {', '.join(sorted(VALID_METHODS))}"
+            )
+
+        # Validate timeout
+        timeout = data.get("timeout", 30)
+        if not (1 <= timeout <= 300):
+            raise ValueError(f"timeout must be in range 1-300, got {timeout}")
+
+        # Parse nested configs
+        retry_data = data.get("retry")
+        retry = RetryConfig.from_dict(retry_data) if retry_data else None
+
+        capture_data = data.get("capture_response")
+        capture = CaptureConfig.from_dict(capture_data) if capture_data else None
+
+        return cls(
+            url=url,
+            webhook_id=webhook_id,
+            method=method,
+            headers=data.get("headers", {}),
+            payload=data.get("payload"),
+            timeout=timeout,
+            retry=retry,
+            on_success=data.get("on_success"),
+            on_failure=data.get("on_failure"),
+            capture_response=capture,
+        )
+
+    @staticmethod
+    def _validate_url(url: str) -> None:
+        """Validate URL scheme is http or https.
+
+        Args:
+            url: URL string to validate.
+
+        Raises:
+            ValueError: If URL scheme is not http or https.
+        """
+        parsed = urlparse(url)
+        if parsed.scheme not in ("http", "https"):
+            raise ValueError(
+                f"Invalid URL scheme '{parsed.scheme}'. Only http and https are allowed."
+            )
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to dict.
+
+        Returns:
+            Dict representation suitable for YAML serialization.
+        """
+        result: dict[str, Any] = {
+            "method": self.method,
+            "timeout": self.timeout,
+        }
+
+        if self.url:
+            result["url"] = self.url
+        if self.webhook_id:
+            result["webhook_id"] = self.webhook_id
+        if self.headers:
+            result["headers"] = self.headers
+        if self.payload is not None:
+            result["payload"] = self.payload
+        if self.retry:
+            result["retry"] = self.retry.to_dict()
+        if self.on_success:
+            result["on_success"] = self.on_success
+        if self.on_failure:
+            result["on_failure"] = self.on_failure
+        if self.capture_response:
+            result["capture_response"] = self.capture_response.to_dict()
+
+        return result