gobby 0.2.5__py3-none-any.whl

gobby/workflows/approval_flow.py

@@ -0,0 +1,138 @@
+"""
+Approval flow handling for workflow engine.
+
+Extracted from engine.py to reduce complexity.
+Handles user approval requests and responses for workflow gates.
+"""
+
+import logging
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING, Any
+
+from gobby.hooks.events import HookEvent, HookResponse
+
+from .evaluator import check_approval_response
+
+if TYPE_CHECKING:
+    from .definitions import WorkflowState
+    from .evaluator import ConditionEvaluator
+    from .state_manager import WorkflowStateManager
+
+logger = logging.getLogger(__name__)
+
+
+def handle_approval_response(
+    event: HookEvent,
+    state: "WorkflowState",
+    current_step: Any,
+    evaluator: "ConditionEvaluator",
+    state_manager: "WorkflowStateManager",
+) -> HookResponse | None:
+    """
+    Handle user response to approval request.
+
+    Called on BEFORE_AGENT events to check if user is responding to
+    a pending approval request.
+
+    Args:
+        event: The hook event
+        state: Current workflow state
+        current_step: Current workflow step definition
+        evaluator: Condition evaluator for checking pending approvals
+        state_manager: State manager for persisting state changes
+
+    Returns:
+        HookResponse if approval was handled, None otherwise.
+    """
+    # Get user prompt from event
+    prompt = event.data.get("prompt", "") if event.data else ""
+
+    # Check if we're waiting for approval
+    if state.approval_pending:
+        response = check_approval_response(prompt)
+
+        if response == "approved":
+            # Mark approval granted
+            condition_id = state.approval_condition_id
+            approved_var = f"_approval_{condition_id}_granted"
+            state.variables[approved_var] = True
+            state.approval_pending = False
+            state.approval_condition_id = None
+            state.approval_prompt = None
+            state.approval_requested_at = None
+            state_manager.save_state(state)
+
+            logger.info(f"User approved condition '{condition_id}' in step '{state.step}'")
+            return HookResponse(
+                decision="allow",
+                context=f"✓ Approval granted for: {state.approval_prompt or 'action'}",
+            )
+
+        elif response == "rejected":
+            # Mark approval rejected
+            condition_id = state.approval_condition_id
+            rejected_var = f"_approval_{condition_id}_rejected"
+            state.variables[rejected_var] = True
+            state.approval_pending = False
+            state.approval_condition_id = None
+            state.approval_prompt = None
+            state.approval_requested_at = None
+            state_manager.save_state(state)
+
+            logger.info(f"User rejected condition '{condition_id}' in step '{state.step}'")
+            return HookResponse(
+                decision="block",
+                reason="User rejected the approval request.",
+            )
+
+        else:
+            # User didn't respond with approval keyword - remind them
+            return HookResponse(
+                decision="allow",
+                context=(
+                    f"⏳ **Waiting for approval:** {state.approval_prompt}\n\n"
+                    f"Please respond with 'yes' or 'no' to continue."
+                ),
+            )
+
+    # Check if we need to request approval
+    approval_check = evaluator.check_pending_approval(current_step.exit_conditions, state)
+
+    if approval_check and approval_check.needs_approval:
+        # Set approval pending state
+        state.approval_pending = True
+        state.approval_condition_id = approval_check.condition_id
+        state.approval_prompt = approval_check.prompt
+        state.approval_requested_at = datetime.now(UTC)
+        state.approval_timeout_seconds = approval_check.timeout_seconds
+        state_manager.save_state(state)
+
+        logger.info(
+            f"Requesting approval for condition '{approval_check.condition_id}' "
+            f"in step '{state.step}'"
+        )
+        return HookResponse(
+            decision="allow",
+            context=(
+                f"🔔 **Approval Required**\n\n"
+                f"{approval_check.prompt}\n\n"
+                f"Please respond with 'yes' to approve or 'no' to reject."
+            ),
+        )
+
+    if approval_check and approval_check.is_timed_out:
+        # Timeout - treat as rejection
+        condition_id = approval_check.condition_id
+        rejected_var = f"_approval_{condition_id}_rejected"
+        state.variables[rejected_var] = True
+        state.approval_pending = False
+        state.approval_condition_id = None
+        state_manager.save_state(state)
+
+        logger.info(f"Approval timed out for condition '{condition_id}'")
+        return HookResponse(
+            decision="block",
+            reason=f"Approval request timed out after {approval_check.timeout_seconds} seconds.",
+        )
+
+    return None

gobby/workflows/artifact_actions.py

@@ -0,0 +1,103 @@
+"""Artifact capture and read workflow actions.
+
+Extracted from actions.py as part of strangler fig decomposition.
+These functions handle file artifact capture and reading.
+"""
+
+import glob
+import logging
+import os
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+def capture_artifact(
+    state: Any,
+    pattern: str | None = None,
+    save_as: str | None = None,
+) -> dict[str, Any] | None:
+    """Capture an artifact (file) and store its path in state.
+
+    Args:
+        state: WorkflowState object with artifacts dict
+        pattern: Glob pattern to match files
+        save_as: Name to store the artifact under
+
+    Returns:
+        Dict with captured filepath, or None if no match
+    """
+    if not pattern:
+        return None
+
+    # Use iglob generator to avoid building entire list on deep trees
+    # Select the lexicographically smallest match for determinism
+    first_match: str | None = None
+    for match in glob.iglob(pattern, recursive=True):
+        if first_match is None or match < first_match:
+            first_match = match
+
+    if first_match is None:
+        return None
+
+    filepath = os.path.abspath(first_match)
+
+    if save_as:
+        if not state.artifacts:
+            state.artifacts = {}
+        state.artifacts[save_as] = filepath
+
+    return {"captured": filepath}
+
+
+def read_artifact(
+    state: Any,
+    pattern: str | None = None,
+    variable_name: str | None = None,
+) -> dict[str, Any] | None:
+    """Read an artifact's content into a workflow variable.
+
+    Args:
+        state: WorkflowState object with artifacts and variables dicts
+        pattern: Glob pattern or artifact key to read
+        variable_name: Variable name to store content in
+
+    Returns:
+        Dict with read_artifact, variable, and length, or None on error
+    """
+    if not pattern:
+        return None
+
+    if not variable_name:
+        logger.warning("read_artifact: 'as' argument missing")
+        return None
+
+    # Check if pattern matches an existing artifact key first
+    filepath = None
+    if state.artifacts:
+        filepath = state.artifacts.get(pattern)
+
+    if not filepath:
+        # Try as glob pattern - use sorted() for deterministic selection
+        matches = sorted(glob.glob(pattern, recursive=True))
+        if matches:
+            filepath = os.path.abspath(matches[0])
+
+    if not filepath or not os.path.exists(filepath):
+        logger.warning(f"read_artifact: File not found for pattern '{pattern}'")
+        return None
+
+    try:
+        # Use explicit encoding and error handling for cross-platform safety
+        with open(filepath, encoding="utf-8", errors="replace") as f:
+            content = f.read()
+
+        if not state.variables:
+            state.variables = {}
+
+        state.variables[variable_name] = content
+        return {"read_artifact": True, "variable": variable_name, "length": len(content)}
+
+    except Exception as e:
+        logger.error(f"read_artifact: Failed to read {filepath}: {e}")
+        return None

gobby/workflows/audit_helpers.py

@@ -0,0 +1,110 @@
+"""
+Audit logging helper functions for workflow engine.
+
+Extracted from engine.py to reduce complexity.
+These are pure logging functions with no side effects beyond audit.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.storage.workflow_audit import WorkflowAuditManager
+
+logger = logging.getLogger(__name__)
+
+
+def log_tool_call(
+    audit_manager: "WorkflowAuditManager | None",
+    session_id: str,
+    step: str,
+    tool_name: str,
+    result: str,
+    reason: str | None = None,
+    context: dict[str, Any] | None = None,
+) -> None:
+    """Log a tool call permission check to the audit log."""
+    if audit_manager:
+        try:
+            audit_manager.log_tool_call(
+                session_id=session_id,
+                step=step,
+                tool_name=tool_name,
+                result=result,
+                reason=reason,
+                context=context,
+            )
+        except Exception as e:
+            logger.debug(f"Failed to log tool call audit: {e}")
+
+
+def log_rule_eval(
+    audit_manager: "WorkflowAuditManager | None",
+    session_id: str,
+    step: str,
+    rule_id: str,
+    condition: str,
+    result: str,
+    reason: str | None = None,
+    context: dict[str, Any] | None = None,
+) -> None:
+    """Log a rule evaluation to the audit log."""
+    if audit_manager:
+        try:
+            audit_manager.log_rule_eval(
+                session_id=session_id,
+                step=step,
+                rule_id=rule_id,
+                condition=condition,
+                result=result,
+                reason=reason,
+                context=context,
+            )
+        except Exception as e:
+            logger.debug(f"Failed to log rule eval audit: {e}")
+
+
+def log_transition(
+    audit_manager: "WorkflowAuditManager | None",
+    session_id: str,
+    from_step: str,
+    to_step: str,
+    reason: str | None = None,
+    context: dict[str, Any] | None = None,
+) -> None:
+    """Log a step transition to the audit log."""
+    if audit_manager:
+        try:
+            audit_manager.log_transition(
+                session_id=session_id,
+                from_step=from_step,
+                to_step=to_step,
+                reason=reason,
+                context=context,
+            )
+        except Exception as e:
+            logger.debug(f"Failed to log transition audit: {e}")
+
+
+def log_approval(
+    audit_manager: "WorkflowAuditManager | None",
+    session_id: str,
+    step: str,
+    result: str,
+    condition_id: str | None = None,
+    prompt: str | None = None,
+    context: dict[str, Any] | None = None,
+) -> None:
+    """Log an approval gate event to the audit log."""
+    if audit_manager:
+        try:
+            audit_manager.log_approval(
+                session_id=session_id,
+                step=step,
+                result=result,
+                condition_id=condition_id,
+                prompt=prompt,
+                context=context,
+            )
+        except Exception as e:
+            logger.debug(f"Failed to log approval audit: {e}")

gobby/workflows/autonomous_actions.py

@@ -0,0 +1,286 @@
+"""Autonomous execution workflow actions.
+
+Actions for managing autonomous loop execution including:
+- Progress tracking (start, stop, record)
+- Stuck detection (detect task loops, tool loops)
+- Task selection recording
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.autonomous.progress_tracker import ProgressTracker, ProgressType
+    from gobby.autonomous.stuck_detector import StuckDetector
+    from gobby.workflows.definitions import WorkflowState
+
+logger = logging.getLogger(__name__)
+
+
+def start_progress_tracking(
+    progress_tracker: "ProgressTracker | None",
+    session_id: str,
+    state: "WorkflowState",
+) -> dict[str, Any]:
+    """Start progress tracking for a session.
+
+    Marks the session as actively being tracked and clears any
+    previous progress data.
+
+    Args:
+        progress_tracker: ProgressTracker instance
+        session_id: The session to track
+        state: Current workflow state (updated with tracking info)
+
+    Returns:
+        Dict with success status
+    """
+    if not progress_tracker:
+        logger.warning("No progress_tracker available")
+        return {"success": False, "error": "Progress tracker not available"}
+
+    # Clear any existing progress data
+    progress_tracker.clear_session(session_id)
+
+    # Mark as tracking in workflow state
+    state.variables["_progress_tracking_active"] = True
+
+    logger.info(f"Started progress tracking for session {session_id}")
+    return {"success": True, "session_id": session_id}
+
+
+def stop_progress_tracking(
+    progress_tracker: "ProgressTracker | None",
+    session_id: str,
+    state: "WorkflowState",
+    keep_data: bool = False,
+) -> dict[str, Any]:
+    """Stop progress tracking for a session.
+
+    Args:
+        progress_tracker: ProgressTracker instance
+        session_id: The session to stop tracking
+        state: Current workflow state
+        keep_data: If True, preserve progress data; otherwise clear it
+
+    Returns:
+        Dict with success status and final summary
+    """
+    if not progress_tracker:
+        return {"success": False, "error": "Progress tracker not available"}
+
+    # Get final summary before stopping
+    summary = progress_tracker.get_summary(session_id)
+
+    # Clear if requested
+    if not keep_data:
+        progress_tracker.clear_session(session_id)
+
+    # Mark as not tracking
+    state.variables["_progress_tracking_active"] = False
+
+    logger.info(f"Stopped progress tracking for session {session_id}")
+    return {
+        "success": True,
+        "session_id": session_id,
+        "final_summary": {
+            "total_events": summary.total_events,
+            "high_value_events": summary.high_value_events,
+            "was_stagnant": summary.is_stagnant,
+        },
+    }
+
+
+def record_progress(
+    progress_tracker: "ProgressTracker | None",
+    session_id: str,
+    progress_type: "ProgressType | str",
+    tool_name: str | None = None,
+    details: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Record a progress event.
+
+    Args:
+        progress_tracker: ProgressTracker instance
+        session_id: The session to record for
+        progress_type: Type of progress (from ProgressType enum or string)
+        tool_name: Optional tool name that generated the event
+        details: Optional additional details
+
+    Returns:
+        Dict with success status and event info
+    """
+    if not progress_tracker:
+        return {"success": False, "error": "Progress tracker not available"}
+
+    from gobby.autonomous.progress_tracker import ProgressType
+
+    # Convert string to enum if needed
+    if isinstance(progress_type, str):
+        try:
+            progress_type = ProgressType(progress_type)
+        except ValueError:
+            progress_type = ProgressType.TOOL_CALL
+
+    event = progress_tracker.record_event(
+        session_id=session_id,
+        progress_type=progress_type,
+        tool_name=tool_name,
+        details=details,
+    )
+
+    return {
+        "success": True,
+        "event": {
+            "type": event.progress_type.value,
+            "is_high_value": event.is_high_value,
+            "timestamp": event.timestamp.isoformat(),
+        },
+    }
+
+
+def detect_task_loop(
+    stuck_detector: "StuckDetector | None",
+    session_id: str,
+    state: "WorkflowState",
+) -> dict[str, Any]:
+    """Detect if the session is stuck in a task selection loop.
+
+    Args:
+        stuck_detector: StuckDetector instance
+        session_id: The session to check
+        state: Current workflow state (updated with detection results)
+
+    Returns:
+        Dict with detection results
+    """
+    if not stuck_detector:
+        return {"is_stuck": False, "error": "Stuck detector not available"}
+
+    result = stuck_detector.detect_task_loop(session_id)
+
+    # Update workflow state
+    state.variables["_task_loop_detected"] = result.is_stuck
+    if result.is_stuck:
+        state.variables["_task_loop_task_id"] = (
+            result.details.get("task_id") if result.details else None
+        )
+
+    return {
+        "is_stuck": result.is_stuck,
+        "reason": result.reason,
+        "layer": result.layer,
+        "details": result.details,
+        "suggested_action": result.suggested_action,
+    }
+
+
+def detect_stuck(
+    stuck_detector: "StuckDetector | None",
+    session_id: str,
+    state: "WorkflowState",
+) -> dict[str, Any]:
+    """Run full stuck detection (all layers).
+
+    Args:
+        stuck_detector: StuckDetector instance
+        session_id: The session to check
+        state: Current workflow state (updated with detection results)
+
+    Returns:
+        Dict with detection results and optional inject_context
+    """
+    if not stuck_detector:
+        return {"is_stuck": False, "error": "Stuck detector not available"}
+
+    result = stuck_detector.is_stuck(session_id)
+
+    # Update workflow state
+    state.variables["_is_stuck"] = result.is_stuck
+    state.variables["_stuck_layer"] = result.layer
+    state.variables["_stuck_reason"] = result.reason
+
+    response: dict[str, Any] = {
+        "is_stuck": result.is_stuck,
+        "reason": result.reason,
+        "layer": result.layer,
+        "details": result.details,
+        "suggested_action": result.suggested_action,
+    }
+
+    # Add context injection if stuck
+    if result.is_stuck:
+        response["inject_context"] = (
+            f"⚠️ **Stuck Detected** ({result.layer})\n\n"
+            f"Reason: {result.reason}\n"
+            f"Suggested action: {result.suggested_action or 'Review approach'}\n\n"
+            f"Consider stopping or changing your approach."
+        )
+
+    return response
+
+
+def record_task_selection(
+    stuck_detector: "StuckDetector | None",
+    session_id: str,
+    task_id: str,
+    context: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Record a task selection for loop detection.
+
+    Called when the autonomous loop selects a task to work on.
+
+    Args:
+        stuck_detector: StuckDetector instance
+        session_id: The session selecting the task
+        task_id: The task being selected
+        context: Optional context about the selection
+
+    Returns:
+        Dict with success status
+    """
+    if not stuck_detector:
+        return {"success": False, "error": "Stuck detector not available"}
+
+    event = stuck_detector.record_task_selection(
+        session_id=session_id,
+        task_id=task_id,
+        context=context,
+    )
+
+    return {
+        "success": True,
+        "task_id": event.task_id,
+        "recorded_at": event.selected_at.isoformat(),
+    }
+
+
+def get_progress_summary(
+    progress_tracker: "ProgressTracker | None",
+    session_id: str,
+) -> dict[str, Any]:
+    """Get a summary of progress for a session.
+
+    Args:
+        progress_tracker: ProgressTracker instance
+        session_id: The session to get summary for
+
+    Returns:
+        Dict with progress summary
+    """
+    if not progress_tracker:
+        return {"error": "Progress tracker not available"}
+
+    summary = progress_tracker.get_summary(session_id)
+
+    return {
+        "total_events": summary.total_events,
+        "high_value_events": summary.high_value_events,
+        "is_stagnant": summary.is_stagnant,
+        "stagnation_duration_seconds": summary.stagnation_duration_seconds,
+        "last_high_value_at": (
+            summary.last_high_value_at.isoformat() if summary.last_high_value_at else None
+        ),
+        "last_event_at": (summary.last_event_at.isoformat() if summary.last_event_at else None),
+        "events_by_type": {k.value: v for k, v in summary.events_by_type.items()},
+    }