gobby 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

gobby/workflows/task_sync_actions.py

@@ -0,0 +1,347 @@
+"""Task sync workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These functions handle task sync import/export and workflow task operations.
+"""
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.storage.database import DatabaseProtocol
+    from gobby.storage.sessions import LocalSessionManager
+    from gobby.workflows.definitions import WorkflowState
+
+logger = logging.getLogger(__name__)
+
+
+async def task_sync_import(
+    task_sync_manager: Any,
+    session_manager: "LocalSessionManager",
+    session_id: str,
+) -> dict[str, Any]:
+    """Import tasks from JSONL file.
+
+    Reads .gobby/tasks.jsonl and imports tasks into SQLite using
+    Last-Write-Wins conflict resolution based on updated_at.
+
+    Args:
+        task_sync_manager: TaskSyncManager instance
+        session_manager: Session manager for project lookup
+        session_id: Current session ID
+
+    Returns:
+        Dict with imported status or error
+    """
+    if not task_sync_manager:
+        logger.debug("task_sync_import: No task_sync_manager available")
+        return {"error": "Task Sync Manager not available"}
+
+    try:
+        # Get project_id from session for project-scoped sync
+        project_id = None
+        session = await asyncio.to_thread(session_manager.get, session_id)
+        if session:
+            project_id = session.project_id
+
+        await asyncio.to_thread(task_sync_manager.import_from_jsonl, project_id=project_id)
+        logger.info("Task sync import completed")
+        return {"imported": True}
+    except Exception as e:
+        logger.error(f"task_sync_import failed: {e}", exc_info=True)
+        return {"error": str(e)}
+
+
+async def task_sync_export(
+    task_sync_manager: Any,
+    session_manager: "LocalSessionManager",
+    session_id: str,
+) -> dict[str, Any]:
+    """Export tasks to JSONL file.
+
+    Writes tasks and dependencies to .gobby/tasks.jsonl for Git persistence.
+    Uses content hashing to skip writes if nothing changed.
+
+    Args:
+        task_sync_manager: TaskSyncManager instance
+        session_manager: Session manager for project lookup
+        session_id: Current session ID
+
+    Returns:
+        Dict with exported status or error
+    """
+    if not task_sync_manager:
+        logger.debug("task_sync_export: No task_sync_manager available")
+        return {"error": "Task Sync Manager not available"}
+
+    try:
+        # Get project_id from session for project-scoped sync
+        project_id = None
+        session = await asyncio.to_thread(session_manager.get, session_id)
+        if session:
+            project_id = session.project_id
+
+        await asyncio.to_thread(task_sync_manager.export_to_jsonl, project_id=project_id)
+        logger.info("Task sync export completed")
+        return {"exported": True}
+    except Exception as e:
+        logger.error(f"task_sync_export failed: {e}", exc_info=True)
+        return {"error": str(e)}
+
+
+async def persist_tasks(
+    db: "DatabaseProtocol",
+    session_manager: "LocalSessionManager",
+    session_id: str,
+    state: "WorkflowState",
+    tasks: list[dict[str, Any]] | None = None,
+    source: str | None = None,
+    workflow_name: str | None = None,
+    parent_task_id: str | None = None,
+) -> dict[str, Any]:
+    """Persist a list of task dicts to Gobby task system.
+
+    Enhanced to support workflow integration with ID mapping.
+
+    Args:
+        db: Database instance
+        session_manager: Session manager
+        session_id: Current session ID
+        state: WorkflowState for variables access
+        tasks: List of task dicts
+        source: Variable name containing task list (alternative to tasks)
+        workflow_name: Associate tasks with this workflow
+        parent_task_id: Optional parent task for all created tasks
+
+    Returns:
+        Dict with tasks_persisted count, ids list, and id_mapping dict
+    """
+    # Get tasks from either 'tasks' kwarg or 'source' variable
+    task_list = tasks or []
+
+    if source and state.variables:
+        source_data = state.variables.get(source)
+        if source_data:
+            # Handle nested structure like task_list.tasks
+            if isinstance(source_data, dict) and "tasks" in source_data:
+                task_list = source_data["tasks"]
+            elif isinstance(source_data, list):
+                task_list = source_data
+
+    if not task_list:
+        return {"tasks_persisted": 0, "ids": [], "id_mapping": {}}
+
+    try:
+        from gobby.workflows.task_actions import persist_decomposed_tasks
+
+        current_session = await asyncio.to_thread(session_manager.get, session_id)
+        project_id = current_session.project_id if current_session else "default"
+
+        # Get workflow name from kwargs or state
+        wf_name = workflow_name
+        if not wf_name and state.workflow_name:
+            wf_name = state.workflow_name
+
+        id_mapping = await asyncio.to_thread(
+            persist_decomposed_tasks,
+            db=db,
+            project_id=project_id,
+            tasks_data=task_list,
+            workflow_name=wf_name or "unnamed",
+            parent_task_id=parent_task_id,
+            created_in_session_id=session_id,
+        )
+
+        # Store ID mapping in workflow state for reference
+        if not state.variables:
+            state.variables = {}
+        state.variables["task_id_mapping"] = id_mapping
+
+        return {
+            "tasks_persisted": len(id_mapping),
+            "ids": list(id_mapping.values()),
+            "id_mapping": id_mapping,
+        }
+    except Exception as e:
+        logger.error(f"persist_tasks: Failed: {e}", exc_info=True)
+        return {"error": str(e)}
+
+
+async def get_workflow_tasks(
+    db: "DatabaseProtocol",
+    session_manager: "LocalSessionManager",
+    session_id: str,
+    state: "WorkflowState",
+    workflow_name: str | None = None,
+    include_closed: bool = False,
+    output_as: str | None = None,
+) -> dict[str, Any]:
+    """Get tasks associated with the current workflow.
+
+    Args:
+        db: Database instance
+        session_manager: Session manager
+        session_id: Current session ID
+        state: WorkflowState for variables access
+        workflow_name: Override workflow name (defaults to current)
+        include_closed: Include closed tasks (default: False)
+        output_as: Variable name to store result in
+
+    Returns:
+        Dict with tasks list and count
+    """
+    from gobby.workflows.task_actions import get_workflow_tasks as _get_workflow_tasks
+
+    wf_name = workflow_name
+    if not wf_name and state.workflow_name:
+        wf_name = state.workflow_name
+
+    if not wf_name:
+        return {"error": "No workflow name specified"}
+
+    try:
+        current_session = await asyncio.to_thread(session_manager.get, session_id)
+        project_id = current_session.project_id if current_session else None
+
+        tasks = await asyncio.to_thread(
+            _get_workflow_tasks,
+            db=db,
+            workflow_name=wf_name,
+            project_id=project_id,
+            include_closed=include_closed,
+        )
+
+        # Convert to dicts for YAML/JSON serialization
+        tasks_data = [t.to_dict() for t in tasks]
+
+        # Store in variable if requested
+        if output_as:
+            if not state.variables:
+                state.variables = {}
+            state.variables[output_as] = tasks_data
+
+        # Also update task_list in state for workflow engine use
+        state.task_list = [{"id": t.id, "title": t.title, "status": t.status} for t in tasks]
+
+        return {"tasks": tasks_data, "count": len(tasks)}
+    except Exception as e:
+        logger.error(f"get_workflow_tasks: Failed: {e}", exc_info=True)
+        return {"error": str(e)}
+
+
+async def update_workflow_task(
+    db: "DatabaseProtocol",
+    state: "WorkflowState",
+    task_id: str | None = None,
+    status: str | None = None,
+    verification: str | None = None,
+    validation_status: str | None = None,
+    validation_feedback: str | None = None,
+) -> dict[str, Any]:
+    """Update a task from workflow context.
+
+    Args:
+        db: Database instance
+        state: WorkflowState for task_list access
+        task_id: ID of task to update (required)
+        status: New status
+        verification: Verification result
+        validation_status: Validation status
+        validation_feedback: Validation feedback
+
+    Returns:
+        Dict with updated task data
+    """
+    from gobby.workflows.task_actions import update_task_from_workflow
+
+    tid = task_id
+    if not tid:
+        # Try to get from current_task_index in state
+        if state.task_list and state.current_task_index is not None:
+            idx = state.current_task_index
+            if 0 <= idx < len(state.task_list):
+                tid = state.task_list[idx].get("id")
+
+    if not tid:
+        return {"error": "No task_id specified"}
+
+    try:
+        task = await asyncio.to_thread(
+            update_task_from_workflow,
+            db=db,
+            task_id=tid,
+            status=status,
+            verification=verification,
+            validation_status=validation_status,
+            validation_feedback=validation_feedback,
+        )
+
+        if task:
+            return {"updated": True, "task": task.to_dict()}
+        return {"updated": False, "error": "Task not found"}
+    except Exception as e:
+        logger.error(f"update_workflow_task: Failed for task {tid}: {e}", exc_info=True)
+        return {"updated": False, "error": str(e)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_task_sync_import(context: Any, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for task_sync_import."""
+    return await task_sync_import(
+        task_sync_manager=context.task_sync_manager,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+    )
+
+
+async def handle_task_sync_export(context: Any, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for task_sync_export."""
+    return await task_sync_export(
+        task_sync_manager=context.task_sync_manager,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+    )
+
+
+async def handle_persist_tasks(context: Any, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for persist_tasks."""
+    return await persist_tasks(
+        db=context.db,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        state=context.state,
+        tasks=kwargs.get("tasks"),
+        source=kwargs.get("source"),
+        workflow_name=kwargs.get("workflow_name"),
+        parent_task_id=kwargs.get("parent_task_id"),
+    )
+
+
+async def handle_get_workflow_tasks(context: Any, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for get_workflow_tasks."""
+    return await get_workflow_tasks(
+        db=context.db,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        state=context.state,
+        workflow_name=kwargs.get("workflow_name"),
+        include_closed=kwargs.get("include_closed", False),
+        output_as=kwargs.get("as"),
+    )
+
+
+async def handle_update_workflow_task(context: Any, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for update_workflow_task."""
+    return await update_workflow_task(
+        db=context.db,
+        state=context.state,
+        task_id=kwargs.get("task_id"),
+        status=kwargs.get("status"),
+        verification=kwargs.get("verification"),
+        validation_status=kwargs.get("validation_status"),
+        validation_feedback=kwargs.get("validation_feedback"),
+    )

gobby/workflows/todo_actions.py

@@ -4,9 +4,13 @@ Extracted from actions.py as part of strangler fig decomposition.
 These functions handle TODO.md file operations.
 """
 
+import asyncio
 import logging
 import os
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
 
 logger = logging.getLogger(__name__)
 
@@ -82,3 +86,32 @@ def mark_todo_complete(
     except Exception as e:
         logger.error(f"mark_todo_complete: Failed: {e}")
         return {"error": str(e)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_write_todos(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for write_todos."""
+    return await asyncio.to_thread(
+        write_todos,
+        todos=kwargs.get("todos", []),
+        filename=kwargs.get("filename", "TODO.md"),
+        mode=kwargs.get("mode", "w"),
+    )
+
+
+async def handle_mark_todo_complete(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for mark_todo_complete."""
+    todo_text = kwargs.get("todo_text")
+    if not todo_text:
+        return {"error": "Missing required parameter: todo_text"}
+
+    return await asyncio.to_thread(
+        mark_todo_complete,
+        todo_text,
+        kwargs.get("filename", "TODO.md"),
+    )

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.6.dist-info → gobby-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.6
+Version: 0.2.8
 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
@@ -39,6 +39,7 @@ Requires-Dist: gitingest>=0.3.1
 Requires-Dist: scikit-learn>=1.0.0
 Requires-Dist: textual>=7.3.0
 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
@@ -378,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