gobby 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

gobby/workflows/webhook_actions.py

@@ -0,0 +1,185 @@
+"""Webhook workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These functions handle webhook HTTP request execution from workflows.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+from urllib.parse import urlparse, urlunparse
+
+if TYPE_CHECKING:
+    from gobby.workflows.definitions import WorkflowState
+    from gobby.workflows.templates import TemplateEngine
+
+logger = logging.getLogger(__name__)
+
+
+async def execute_webhook(
+    template_engine: "TemplateEngine",
+    state: "WorkflowState",
+    config: Any | None,
+    url: str | None = None,
+    webhook_id: str | None = None,
+    method: str = "POST",
+    headers: dict[str, str] | None = None,
+    payload: dict[str, Any] | str | None = None,
+    timeout: int = 30,
+    retry: dict[str, Any] | None = None,
+    capture_response: dict[str, str] | None = None,
+) -> dict[str, Any]:
+    """Execute a webhook HTTP request.
+
+    Args:
+        template_engine: Template engine for interpolation
+        state: WorkflowState for variables/artifacts access
+        config: Daemon config for webhook_secrets
+        url: Target URL for the request
+        webhook_id: ID of a pre-configured webhook (alternative to url)
+        method: HTTP method (GET, POST, PUT, PATCH, DELETE)
+        headers: Request headers dict
+        payload: Request body as dict or string
+        timeout: Request timeout in seconds
+        retry: Retry configuration dict
+        capture_response: Response capture config
+
+    Returns:
+        Dict with success status, status_code, and captured response data.
+    """
+    from gobby.workflows.webhook import WebhookAction
+    from gobby.workflows.webhook_executor import WebhookExecutor
+
+    # Build kwargs dict for WebhookAction
+    webhook_kwargs: dict[str, Any] = {
+        "method": method,
+        "timeout": timeout,
+    }
+    if url:
+        webhook_kwargs["url"] = url
+    if webhook_id:
+        webhook_kwargs["webhook_id"] = webhook_id
+    if headers:
+        webhook_kwargs["headers"] = headers
+    if payload:
+        webhook_kwargs["payload"] = payload
+    if retry:
+        webhook_kwargs["retry"] = retry
+    if capture_response:
+        webhook_kwargs["capture_response"] = capture_response
+
+    try:
+        # Parse WebhookAction from kwargs to validate config
+        webhook_action = WebhookAction.from_dict(webhook_kwargs)
+    except ValueError as e:
+        logger.error(f"Invalid webhook action config: {e}")
+        return {"success": False, "error": str(e)}
+
+    # Build context for variable interpolation
+    interpolation_context: dict[str, Any] = {}
+    if state.variables:
+        interpolation_context["state"] = {"variables": state.variables}
+    if state.artifacts:
+        interpolation_context["artifacts"] = state.artifacts
+
+    # Get secrets from config if available
+    secrets: dict[str, str] = {}
+    if config:
+        secrets = getattr(config, "webhook_secrets", {})
+
+    # Create executor with template engine for payload interpolation
+    executor = WebhookExecutor(
+        template_engine=template_engine,
+        secrets=secrets,
+    )
+
+    # Execute the webhook
+    if webhook_action.url:
+        result = await executor.execute(
+            url=webhook_action.url,
+            method=webhook_action.method,
+            headers=webhook_action.headers,
+            payload=webhook_action.payload,
+            timeout=webhook_action.timeout,
+            retry_config=webhook_action.retry.to_dict() if webhook_action.retry else None,
+            context=interpolation_context,
+        )
+    elif webhook_action.webhook_id:
+        # webhook_id execution requires a registry which would be configured
+        # at the daemon level - for now we return an error if no registry
+        logger.warning("webhook_id execution not yet supported without registry")
+        return {"success": False, "error": "webhook_id requires configured webhook registry"}
+    else:
+        return {"success": False, "error": "Either url or webhook_id is required"}
+
+    # Capture response into workflow variables if configured
+    if webhook_action.capture_response:
+        if not state.variables:
+            state.variables = {}
+
+        capture = webhook_action.capture_response
+        if capture.status_var and result.status_code is not None:
+            state.variables[capture.status_var] = result.status_code
+        if capture.body_var and result.body is not None:
+            # Try to parse as JSON, fall back to raw string
+            json_body = result.json_body()
+            state.variables[capture.body_var] = json_body if json_body else result.body
+        if capture.headers_var and result.headers is not None:
+            state.variables[capture.headers_var] = result.headers
+
+    # Sanitize URL for logging (remove query params which may contain secrets)
+    def _sanitize_url(url: str | None) -> str:
+        if not url:
+            return "<no-url>"
+        try:
+            parsed = urlparse(url)
+            # Remove query string for logging
+            sanitized = urlunparse((parsed.scheme, parsed.netloc, parsed.path, "", "", ""))
+            return sanitized or url
+        except Exception:
+            return "<invalid-url>"
+
+    sanitized_url = _sanitize_url(webhook_action.url)
+
+    # Log outcome
+    if result.success:
+        logger.info(
+            f"Webhook {webhook_action.method} {sanitized_url} succeeded: {result.status_code}"
+        )
+    else:
+        logger.warning(
+            f"Webhook {webhook_action.method} {sanitized_url} failed: "
+            f"{result.error or result.status_code}"
+        )
+
+    return {
+        "success": result.success,
+        "status_code": result.status_code,
+        "error": result.error,
+        "body": result.body if result.success else None,
+    }
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_webhook(
+    context: Any, config: Any | None = None, **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for execute_webhook.
+
+    Note: config is passed via closure from register_defaults.
+    """
+    return await execute_webhook(
+        template_engine=context.template_engine,
+        state=context.state,
+        config=config,
+        url=kwargs.get("url"),
+        webhook_id=kwargs.get("webhook_id"),
+        method=kwargs.get("method", "POST"),
+        headers=kwargs.get("headers"),
+        payload=kwargs.get("payload"),
+        timeout=kwargs.get("timeout", 30),
+        retry=kwargs.get("retry"),
+        capture_response=kwargs.get("capture_response"),
+    )

{gobby-0.2.5.dist-info → gobby-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.5
+Version: 0.2.7
 Summary: A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks.
 Author-email: Josh Wilhelmi <josh@gobby.ai>
 License-Expression: MIT
@@ -38,8 +38,10 @@ Requires-Dist: msgspec>=0.20.0
 Requires-Dist: gitingest>=0.3.1
 Requires-Dist: scikit-learn>=1.0.0
 Requires-Dist: textual>=7.3.0
-Requires-Dist: mem0ai
 Requires-Dist: memu-py>=1.0.0
+Requires-Dist: python-multipart>=0.0.22
+Provides-Extra: mem0
+Requires-Dist: mem0ai; extra == "mem0"
 Dynamic: license-file
 
 <!-- markdownlint-disable MD033 MD041 -->
@@ -149,35 +151,92 @@ call_tool("gobby-worktrees", "spawn_agent_in_worktree", {
 })
 ```
 
-## Quick Start
+### 🔗 Claude Code Task Integration
+
+Gobby transparently intercepts Claude Code's built-in task system (TaskCreate, TaskUpdate, etc.) and syncs operations to Gobby's persistent task store. Benefits:
+
+- **Tasks persist** across sessions (unlike CC's session-scoped tasks)
+- **Commit linking** — tasks auto-link to git commits
+- **Validation gates** — define criteria for task completion
+- **LLM expansion** — break complex tasks into subtasks
+
+No configuration needed — just use Claude Code's native task tools and Gobby handles the rest.
+
+### 📚 Skills System
+
+Reusable instructions that teach agents how to perform specific tasks. Compatible with the [Agent Skills specification](https://agentskills.io) and SkillPort.
+
+- **Core skills** bundled with Gobby for tasks, sessions, memory, workflows
+- **Project skills** in `.gobby/skills/` for team-specific patterns
+- **Install from anywhere** — GitHub repos, local paths, ZIP archives
+- **Search and discovery** — TF-IDF and semantic search across your skill library
+
+```bash
+# Install a skill from GitHub
+gobby skills install github:user/repo/skills/my-skill
+
+# Search for relevant skills
+gobby skills search "testing coverage"
+```
+
+## Installation
+
+### Try it instantly
+```bash
+uvx gobby --help
+```
 
+### Install globally
 ```bash
-# Clone and install
-git clone https://github.com/GobbyAI/gobby.git
-cd gobby
-uv sync
+# With uv (recommended)
+uv tool install gobby
 
+# With pipx
+pipx install gobby
+
+# With pip
+pip install gobby
+```
+
+**Requirements:** Python 3.13+
+
+## Quick Start
+
+```bash
 # Start the daemon
-uv run gobby start
+gobby start
 
 # In your project directory
-uv run gobby init
-uv run gobby install  # Installs hooks for detected CLIs
-
-# Optional: install globally
-uv pip install -e .
+gobby init
+gobby install  # Installs hooks for detected CLIs
 ```
 
-**Requirements:** Python 3.11+, [uv](https://github.com/astral-sh/uv), at least one AI CLI ([Claude Code](https://claude.ai/code), [Gemini CLI](https://github.com/google-gemini/gemini-cli), or [Codex CLI](https://github.com/openai/codex))
+**Requirements:** At least one AI CLI ([Claude Code](https://claude.ai/code), [Gemini CLI](https://github.com/google-gemini/gemini-cli), or [Codex CLI](https://github.com/openai/codex))
 
 Works with your Claude, Gemini, or Codex subscriptions—or bring your own API keys. Local model support coming soon.
 
 ## Configure Your AI CLI
 
-Add Gobby as an MCP server:
+Add Gobby as an MCP server. Choose the `command` and `args` that match your installation:
+
+- **pip/pipx install**: `"command": "gobby"`, `"args": ["mcp-server"]`
+- **uv tool install**: `"command": "uv"`, `"args": ["run", "gobby", "mcp-server"]`
 
 **Claude Code** (`.mcp.json` or `~/.claude.json`):
 
+```json
+{
+  "mcpServers": {
+    "gobby": {
+      "command": "gobby",
+      "args": ["mcp-server"]
+    }
+  }
+}
+```
+
+Or with uv:
+
 ```json
 {
   "mcpServers": {
@@ -195,8 +254,8 @@ Add Gobby as an MCP server:
 {
   "mcpServers": {
     "gobby": {
-      "command": "uv",
-      "args": ["run", "gobby", "mcp-server"]
+      "command": "gobby",
+      "args": ["mcp-server"]
     }
   }
 }
@@ -206,8 +265,8 @@ Add Gobby as an MCP server:
 
 ```toml
 [mcp_servers.gobby]
-command = "uv"
-args = ["run", "gobby", "mcp-server"]
+command = "gobby"
+args = ["mcp-server"]
 ```
 
 **Gemini Antigravity** (`~/.gemini/antigravity/mcp_config.json`):
@@ -256,7 +315,7 @@ AI CLI (Claude/Gemini/Codex)
    Hook Dispatcher
         │ HTTP POST
         ▼
-  Gobby Daemon (:8765)
+  Gobby Daemon (:60887)
         │
    ┌────┴────┐
    ▼         ▼
@@ -298,9 +357,12 @@ Gobby exposes tools via MCP that your AI coding assistant can use:
 **Worktrees** (`gobby-worktrees`)  
 `create_worktree`, `spawn_agent_in_worktree`, `list_worktrees`
 
-**MCP Proxy**  
+**MCP Proxy**
 `list_mcp_servers`, `add_mcp_server`, `import_mcp_server`, `list_tools`, `get_tool_schema`, `call_tool`, `recommend_tools`
 
+**Skills** (`gobby-skills`)
+`list_skills`, `get_skill`, `search_skills`, `install_skill`, `remove_skill`, `update_skill`
+
 ## For AI Agents
 
 **If you're an AI agent reading this:** Check out [docs/AGENT_INSTRUCTIONS.md](docs/AGENT_INSTRUCTIONS.md) for your operating procedures, and [CLAUDE.md](CLAUDE.md) for Claude Code-specific guidance.
@@ -317,6 +379,10 @@ See [ROADMAP.md](ROADMAP.md) for the full plan, but highlights:
 
 **Vision:** Always local first, but Pro cloud features to keep the lights on: Fleet management (manage sessions across multiple machines), Plugin ecosystem, Team workflows, Enterprise hardening
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history and detailed changes.
+
 ## Development
 
 ```bash