gobby 0.2.5__py3-none-any.whl

gobby/workflows/git_utils.py

@@ -0,0 +1,96 @@
+"""Git utility functions for workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These are pure utility functions with no ActionContext dependency.
+"""
+
+import logging
+import subprocess  # nosec B404 - subprocess needed for git commands
+
+logger = logging.getLogger(__name__)
+
+
+def get_git_status() -> str:
+    """Get git status for current directory.
+
+    Returns:
+        Short git status output, or error message if not a git repo.
+    """
+    try:
+        result = subprocess.run(  # nosec B603 B607 - hardcoded git command
+            ["git", "status", "--short"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return result.stdout.strip() or "No changes"
+    except Exception:
+        return "Not a git repository or git not available"
+
+
+def get_recent_git_commits(max_commits: int = 10) -> list[dict[str, str]]:
+    """Get recent git commits with hash and message.
+
+    Args:
+        max_commits: Maximum number of commits to return
+
+    Returns:
+        List of dicts with 'hash' and 'message' keys
+    """
+    try:
+        result = subprocess.run(  # nosec B603 B607 - hardcoded git command
+            ["git", "log", f"-{max_commits}", "--format=%H|%s"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if result.returncode != 0:
+            return []
+
+        commits = []
+        for line in result.stdout.strip().split("\n"):
+            if "|" in line:
+                hash_part, message = line.split("|", 1)
+                commits.append({"hash": hash_part, "message": message})
+        return commits
+    except Exception:
+        return []
+
+
+def get_file_changes() -> str:
+    """Get detailed file changes from git.
+
+    Returns:
+        Formatted string with modified/deleted and untracked files.
+    """
+    try:
+        # Get changed files with status
+        diff_result = subprocess.run(  # nosec B603 B607 - hardcoded git command
+            ["git", "diff", "HEAD", "--name-status"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        # Get untracked files
+        untracked_result = subprocess.run(  # nosec B603 B607 - hardcoded git command
+            ["git", "ls-files", "--others", "--exclude-standard"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+
+        # Combine results
+        changes = []
+        if diff_result.stdout.strip():
+            changes.append("Modified/Deleted:")
+            changes.append(diff_result.stdout.strip())
+
+        if untracked_result.stdout.strip():
+            changes.append("\nUntracked:")
+            changes.append(untracked_result.stdout.strip())
+
+        return "\n".join(changes) if changes else "No changes"
+
+    except Exception:
+        return "Unable to determine file changes"

gobby/workflows/hooks.py

@@ -0,0 +1,169 @@
+import asyncio
+import logging
+import threading
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.events import HookEvent, HookResponse
+
+if TYPE_CHECKING:
+    from .engine import WorkflowEngine
+
+logger = logging.getLogger(__name__)
+
+
+class WorkflowHookHandler:
+    """
+    Integrates WorkflowEngine into the HookManager.
+    Wraps the async engine to be callable from synchronous hooks.
+    """
+
+    def __init__(
+        self,
+        engine: "WorkflowEngine",
+        loop: asyncio.AbstractEventLoop | None = None,
+        timeout: float = 30.0,  # Timeout for workflow operations in seconds
+        enabled: bool = True,
+    ):
+        self.engine = engine
+        self._loop = loop
+        # Convert 0 to None for asyncio (0 means no timeout)
+        self.timeout = timeout if timeout > 0 else None
+        self._enabled = enabled
+
+        # If no loop provided, try to get one or create one for this thread
+        if not self._loop:
+            try:
+                self._loop = asyncio.get_running_loop()
+            except RuntimeError:
+                pass
+
+    def handle_all_lifecycles(self, event: HookEvent) -> HookResponse:
+        """
+        Handle a hook event by discovering and evaluating all lifecycle workflows.
+
+        This is the preferred method - it automatically discovers all lifecycle
+        workflows and evaluates them in priority order. Replaces the need to
+        call handle_lifecycle() with a specific workflow name.
+
+        Args:
+            event: The hook event to handle
+
+        Returns:
+            Merged HookResponse from all workflows
+        """
+        if not self._enabled:
+            return HookResponse(decision="allow")
+
+        try:
+            if self._loop and self._loop.is_running():
+                if threading.current_thread() is threading.main_thread():
+                    return HookResponse(decision="allow")
+                else:
+                    future = asyncio.run_coroutine_threadsafe(
+                        self.engine.evaluate_all_lifecycle_workflows(event),
+                        self._loop,
+                    )
+                    return future.result(timeout=self.timeout)
+
+            try:
+                asyncio.get_running_loop()
+                # If we get here, a loop is running
+                logger.warning("Could not run workflow engine: Event loop is already running.")
+                return HookResponse(decision="allow")
+            except RuntimeError:
+                # No loop running, safe to use asyncio.run
+                return asyncio.run(self.engine.evaluate_all_lifecycle_workflows(event))
+
+        except Exception as e:
+            logger.error(f"Error handling all lifecycle workflows: {e}", exc_info=True)
+            return HookResponse(decision="allow")
+
+    def handle(self, event: HookEvent) -> HookResponse:
+        """
+        Handle a hook event by delegating to the workflow engine.
+        Handles the sync/async bridge.
+        """
+        if not self._enabled:
+            return HookResponse(decision="allow")
+
+        try:
+            # We need to run the async self.engine.handle_event(event) synchronously
+
+            # Case 1: We have a captured loop (main loop) and we are likely in a thread
+            # This is the common case for FastAPI sync endpoints
+            if self._loop and self._loop.is_running():
+                if threading.current_thread() is threading.main_thread():
+                    # We are on the main thread and the loop is running.
+                    # We cannot block here without deadlock if we use run_until_complete.
+                    # But HookManager.handle is synchronous, so this is a tricky spot.
+                    # Ideally, HookManager should await, but it's not async.
+                    # For now, we return allow and log a warning if we can't run.
+                    # OR we create a task and return allow (fire and forget), but we need the result.
+
+                    # Actually, if we are here, we are blocking the event loop!
+                    # This implementation assumes HookManager.handle is run in a threadpool (def handle vs async def handle).
+                    # Pydantic/FastAPI runs sync def routes in threadpool.
+                    pass
+                else:
+                    # We are in a thread, loop is in another thread.
+                    # Safe to block this thread waiting for loop.
+                    future = asyncio.run_coroutine_threadsafe(
+                        self.engine.handle_event(event), self._loop
+                    )
+                    return future.result(timeout=self.timeout)
+
+            # Case 2: No loop running, or we just want to run it.
+            # Create a new loop or use asyncio.run if appropriate
+            try:
+                asyncio.get_running_loop()
+                # If we get here, a loop is running
+                logger.warning(
+                    "Could not run workflow engine: Event loop is already running and we are blocking it."
+                )
+                return HookResponse(decision="allow")
+            except RuntimeError:
+                # No loop running, safe to use asyncio.run
+                return asyncio.run(self.engine.handle_event(event))
+
+        except Exception as e:
+            logger.error(f"Error handling workflow hook: {e}", exc_info=True)
+            return HookResponse(decision="allow")
+
+    def handle_lifecycle(
+        self, workflow_name: str, event: HookEvent, context_data: dict[str, Any] | None = None
+    ) -> HookResponse:
+        """
+        Handle a lifecycle workflow event.
+        """
+        if not self._enabled:
+            return HookResponse(decision="allow")
+
+        logger.debug(
+            f"handle_lifecycle called: workflow={workflow_name}, event_type={event.event_type}"
+        )
+        try:
+            if self._loop and self._loop.is_running():
+                if threading.current_thread() is threading.main_thread():
+                    # See comment in handle() about blocking main thread loop
+                    return HookResponse(decision="allow")
+                else:
+                    future = asyncio.run_coroutine_threadsafe(
+                        self.engine.evaluate_lifecycle_triggers(workflow_name, event, context_data),
+                        self._loop,
+                    )
+                    return future.result(timeout=self.timeout)
+
+            try:
+                asyncio.get_running_loop()
+                # If we get here, a loop is running
+                logger.warning("Could not run workflow engine: Event loop is already running.")
+                return HookResponse(decision="allow")
+            except RuntimeError:
+                # No loop running, safe to use asyncio.run
+                return asyncio.run(
+                    self.engine.evaluate_lifecycle_triggers(workflow_name, event, context_data)
+                )
+
+        except Exception as e:
+            logger.error(f"Error handling lifecycle workflow: {e}", exc_info=True)
+            return HookResponse(decision="allow")