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

gobby/workflows/mcp_actions.py

@@ -5,7 +5,10 @@ These functions handle MCP tool calls from workflows.
 """
 
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
 
 logger = logging.getLogger(__name__)
 
@@ -58,3 +61,19 @@ async def call_mcp_tool(
     except Exception as e:
         logger.error(f"call_mcp_tool: Failed: {e}")
         return {"error": str(e)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_call_mcp_tool(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for call_mcp_tool."""
+    return await call_mcp_tool(
+        mcp_manager=context.mcp_manager,
+        state=context.state,
+        server_name=kwargs.get("server_name"),
+        tool_name=kwargs.get("tool_name"),
+        arguments=kwargs.get("arguments"),
+        output_as=kwargs.get("as"),
+    )

gobby/workflows/memory_actions.py

@@ -344,3 +344,83 @@ async def memory_extract(
     except Exception as e:
         logger.error(f"memory_extract: Failed: {e}", exc_info=True)
         return {"error": str(e)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+if __name__ != "__main__":
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from gobby.workflows.actions import ActionContext
+
+
+async def handle_memory_sync_import(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for memory_sync_import."""
+    return await memory_sync_import(context.memory_sync_manager)
+
+
+async def handle_memory_sync_export(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for memory_sync_export."""
+    return await memory_sync_export(context.memory_sync_manager)
+
+
+async def handle_memory_save(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for memory_save."""
+    return await memory_save(
+        memory_manager=context.memory_manager,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        content=kwargs.get("content"),
+        memory_type=kwargs.get("memory_type", "fact"),
+        importance=kwargs.get("importance", 0.5),
+        tags=kwargs.get("tags"),
+        project_id=kwargs.get("project_id"),
+    )
+
+
+async def handle_memory_recall_relevant(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for memory_recall_relevant."""
+    prompt_text = None
+    if context.event_data:
+        # Check both "prompt" (from hook event) and "prompt_text" (legacy/alternative)
+        prompt_text = context.event_data.get("prompt") or context.event_data.get("prompt_text")
+
+    return await memory_recall_relevant(
+        memory_manager=context.memory_manager,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        prompt_text=prompt_text,
+        project_id=kwargs.get("project_id"),
+        limit=kwargs.get("limit", 5),
+        min_importance=kwargs.get("min_importance", 0.3),
+        state=context.state,
+    )
+
+
+async def handle_reset_memory_injection_tracking(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for reset_memory_injection_tracking."""
+    return reset_memory_injection_tracking(state=context.state)
+
+
+async def handle_memory_extract(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for memory_extract."""
+    return await memory_extract(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        memory_manager=context.memory_manager,
+        transcript_processor=context.transcript_processor,
+        min_importance=kwargs.get("min_importance", 0.7),
+        max_memories=kwargs.get("max_memories", 5),
+        dry_run=kwargs.get("dry_run", False),
+    )

gobby/workflows/safe_evaluator.py

@@ -0,0 +1,183 @@
+"""Safe expression evaluation utilities.
+
+Provides AST-based expression evaluation without using eval(),
+and lazy boolean evaluation for deferred computation.
+"""
+
+from __future__ import annotations
+
+import ast
+import operator
+from collections.abc import Callable
+from typing import Any
+
+__all__ = ["LazyBool", "SafeExpressionEvaluator"]
+
+
+class LazyBool:
+    """Lazy boolean that defers computation until first access.
+
+    Used to avoid expensive operations (git status, DB queries) when
+    evaluating block_tools conditions that don't reference certain values.
+
+    The computation is triggered when the value is used in a boolean context
+    (e.g., `if lazy_val:` or `not lazy_val`), which happens during eval().
+    """
+
+    __slots__ = ("_thunk", "_computed", "_value")
+
+    def __init__(self, thunk: Callable[[], bool]) -> None:
+        self._thunk = thunk
+        self._computed = False
+        self._value = False
+
+    def __bool__(self) -> bool:
+        if not self._computed:
+            self._value = self._thunk()
+            self._computed = True
+        return self._value
+
+    def __repr__(self) -> str:
+        if self._computed:
+            return f"LazyBool({self._value})"
+        return "LazyBool(<not computed>)"
+
+
+class SafeExpressionEvaluator(ast.NodeVisitor):
+    """Safe expression evaluator using AST.
+
+    Evaluates simple Python expressions without using eval().
+    Supports boolean operations, comparisons, attribute access, subscripts,
+    and a limited set of allowed function calls.
+    """
+
+    # Comparison operators mapping
+    CMP_OPS: dict[type[ast.cmpop], Callable[[Any, Any], bool]] = {
+        ast.Eq: operator.eq,
+        ast.NotEq: operator.ne,
+        ast.Lt: operator.lt,
+        ast.LtE: operator.le,
+        ast.Gt: operator.gt,
+        ast.GtE: operator.ge,
+        ast.Is: operator.is_,
+        ast.IsNot: operator.is_not,
+        ast.In: lambda a, b: a in b,
+        ast.NotIn: lambda a, b: a not in b,
+    }
+
+    def __init__(
+        self, context: dict[str, Any], allowed_funcs: dict[str, Callable[..., Any]]
+    ) -> None:
+        self.context = context
+        self.allowed_funcs = allowed_funcs
+
+    def evaluate(self, expr: str) -> bool:
+        """Evaluate expression and return boolean result."""
+        try:
+            tree = ast.parse(expr, mode="eval")
+            return bool(self.visit(tree.body))
+        except Exception as e:
+            raise ValueError(f"Invalid expression: {e}") from e
+
+    def visit_BoolOp(self, node: ast.BoolOp) -> bool:
+        """Handle 'and' / 'or' operations."""
+        if isinstance(node.op, ast.And):
+            return all(self.visit(v) for v in node.values)
+        elif isinstance(node.op, ast.Or):
+            return any(self.visit(v) for v in node.values)
+        raise ValueError(f"Unsupported boolean operator: {type(node.op).__name__}")
+
+    def visit_Compare(self, node: ast.Compare) -> bool:
+        """Handle comparison operations (==, !=, <, >, in, not in, etc.)."""
+        left = self.visit(node.left)
+        for op, comparator in zip(node.ops, node.comparators, strict=False):
+            right = self.visit(comparator)
+            op_func = self.CMP_OPS.get(type(op))
+            if op_func is None:
+                raise ValueError(f"Unsupported comparison: {type(op).__name__}")
+            if not op_func(left, right):
+                return False
+            left = right
+        return True
+
+    def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
+        """Handle unary operations (not, -, +)."""
+        operand = self.visit(node.operand)
+        if isinstance(node.op, ast.Not):
+            return not operand
+        elif isinstance(node.op, ast.USub):
+            return -operand
+        elif isinstance(node.op, ast.UAdd):
+            return +operand
+        raise ValueError(f"Unsupported unary operator: {type(node.op).__name__}")
+
+    def visit_Name(self, node: ast.Name) -> Any:
+        """Handle variable names."""
+        name = node.id
+        # Built-in constants
+        if name == "True":
+            return True
+        if name == "False":
+            return False
+        if name == "None":
+            return None
+        # Context variables
+        if name in self.context:
+            return self.context[name]
+        raise ValueError(f"Unknown variable: {name}")
+
+    def visit_Constant(self, node: ast.Constant) -> Any:
+        """Handle literal values (strings, numbers, booleans, None)."""
+        return node.value
+
+    def visit_Call(self, node: ast.Call) -> Any:
+        """Handle function calls (only allowed functions)."""
+        # Get function name
+        if isinstance(node.func, ast.Name):
+            func_name = node.func.id
+        elif isinstance(node.func, ast.Attribute):
+            # Handle method calls like tool_input.get('key')
+            obj = self.visit(node.func.value)
+            method_name = node.func.attr
+            if method_name == "get" and isinstance(obj, dict):
+                args = [self.visit(arg) for arg in node.args]
+                return obj.get(*args)
+            raise ValueError(f"Unsupported method call: {method_name}")
+        else:
+            raise ValueError(f"Unsupported call type: {type(node.func).__name__}")
+
+        # Check if function is allowed
+        if func_name not in self.allowed_funcs:
+            raise ValueError(f"Function not allowed: {func_name}")
+
+        # Evaluate arguments
+        args = [self.visit(arg) for arg in node.args]
+        kwargs = {kw.arg: self.visit(kw.value) for kw in node.keywords if kw.arg}
+
+        return self.allowed_funcs[func_name](*args, **kwargs)
+
+    def visit_Attribute(self, node: ast.Attribute) -> Any:
+        """Handle attribute access (e.g., obj.attr)."""
+        obj = self.visit(node.value)
+        attr = node.attr
+        if isinstance(obj, dict):
+            # Allow dict-style attribute access for convenience
+            if attr in obj:
+                return obj[attr]
+            raise ValueError(f"Key not found: {attr}")
+        if hasattr(obj, attr):
+            return getattr(obj, attr)
+        raise ValueError(f"Attribute not found: {attr}")
+
+    def visit_Subscript(self, node: ast.Subscript) -> Any:
+        """Handle subscript access (e.g., obj['key'] or obj[0])."""
+        obj = self.visit(node.value)
+        key = self.visit(node.slice)
+        try:
+            return obj[key]
+        except (KeyError, IndexError, TypeError) as e:
+            raise ValueError(f"Subscript access failed: {e}") from e
+
+    def generic_visit(self, node: ast.AST) -> Any:
+        """Reject any unsupported AST nodes."""
+        raise ValueError(f"Unsupported expression type: {type(node).__name__}")

gobby/workflows/session_actions.py

@@ -137,3 +137,47 @@ def switch_mode(mode: str | None = None) -> dict[str, Any]:
     )
 
     return {"inject_context": message, "mode_switch": mode}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+if __name__ != "__main__":
+    from typing import TYPE_CHECKING
+
+    if TYPE_CHECKING:
+        from gobby.workflows.actions import ActionContext
+
+
+async def handle_start_new_session(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for start_new_session."""
+    import asyncio
+
+    return await asyncio.to_thread(
+        start_new_session,
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        command=kwargs.get("command"),
+        args=kwargs.get("args"),
+        prompt=kwargs.get("prompt"),
+        cwd=kwargs.get("cwd"),
+    )
+
+
+async def handle_mark_session_status(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for mark_session_status."""
+    return mark_session_status(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        status=kwargs.get("status"),
+        target=kwargs.get("target", "current_session"),
+    )
+
+
+async def handle_switch_mode(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for switch_mode."""
+    return switch_mode(kwargs.get("mode"))

gobby/workflows/state_actions.py

@@ -4,8 +4,12 @@ Extracted from actions.py as part of strangler fig decomposition.
 These functions handle workflow state persistence and variable management.
 """
 
+import asyncio
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
 
 logger = logging.getLogger(__name__)
 
@@ -121,3 +125,58 @@ def mark_loop_complete(state: Any) -> dict[str, Any]:
         state.variables = {}
     state.variables["stop_reason"] = "completed"
     return {"loop_marked_complete": True}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_load_workflow_state(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for load_workflow_state."""
+    return await asyncio.to_thread(
+        load_workflow_state, context.db, context.session_id, context.state
+    )
+
+
+async def handle_save_workflow_state(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for save_workflow_state."""
+    return await asyncio.to_thread(save_workflow_state, context.db, context.state)
+
+
+async def handle_set_variable(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for set_variable.
+
+    Values containing Jinja2 templates ({{ ... }}) are rendered before setting.
+    """
+    value = kwargs.get("value")
+
+    # Render template if value contains Jinja2 syntax
+    if isinstance(value, str) and "{{" in value:
+        template_context = {
+            "variables": context.state.variables or {},
+            "state": context.state,
+        }
+        if context.template_engine:
+            value = context.template_engine.render(value, template_context)
+        else:
+            logger.warning("handle_set_variable: template_engine is None, skipping template render")
+
+    return set_variable(context.state, kwargs.get("name"), value)
+
+
+async def handle_increment_variable(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for increment_variable."""
+    return increment_variable(context.state, kwargs.get("name"), kwargs.get("amount", 1))
+
+
+async def handle_mark_loop_complete(
+    context: "ActionContext", **kwargs: Any
+) -> dict[str, Any] | None:
+    """ActionHandler wrapper for mark_loop_complete."""
+    return mark_loop_complete(context.state)

gobby/workflows/stop_signal_actions.py

@@ -161,3 +161,58 @@ def clear_stop_signal(
 
     cleared = stop_registry.clear(session_id)
     return {"success": True, "cleared": cleared}
+
+
+# --- ActionHandler factory functions ---
+# These create ActionHandler-compatible wrappers that close over the stop_registry.
+# The ActionExecutor calls these factories in _register_defaults() to create handlers
+# that have access to the executor's stop_registry instance.
+
+
+def make_handle_check_stop_signal(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a check_stop_signal handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for check_stop_signal."""
+        return check_stop_signal(
+            stop_registry=stop_registry,
+            session_id=context.session_id,
+            state=context.state,
+            acknowledge=kwargs.get("acknowledge", False),
+        )
+
+    return handler
+
+
+def make_handle_request_stop(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a request_stop handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for request_stop."""
+        return request_stop(
+            stop_registry=stop_registry,
+            session_id=kwargs.get("session_id", context.session_id),
+            source=kwargs.get("source", "workflow"),
+            reason=kwargs.get("reason"),
+        )
+
+    return handler
+
+
+def make_handle_clear_stop_signal(
+    stop_registry: "StopRegistry | None",
+) -> Any:
+    """Factory that creates a clear_stop_signal handler with access to stop_registry."""
+
+    async def handler(context: "Any", **kwargs: Any) -> dict[str, Any] | None:
+        """ActionHandler for clear_stop_signal."""
+        return clear_stop_signal(
+            stop_registry=stop_registry,
+            session_id=kwargs.get("session_id", context.session_id),
+        )
+
+    return handler

gobby/workflows/summary_actions.py

@@ -9,10 +9,13 @@ from __future__ import annotations
 import json
 import logging
 from pathlib import Path
-from typing import Any, Literal
+from typing import TYPE_CHECKING, Any, Literal
 
 from gobby.workflows.git_utils import get_file_changes, get_git_status
 
+if TYPE_CHECKING:
+    from gobby.workflows.actions import ActionContext
+
 logger = logging.getLogger(__name__)
 
 
@@ -359,3 +362,93 @@ async def generate_handoff(
         return {"error": "Failed to generate summary"}
 
     return {"handoff_created": True, "summary_length": summary_result.get("summary_length", 0)}
+
+
+# --- ActionHandler-compatible wrappers ---
+# These match the ActionHandler protocol: (context: ActionContext, **kwargs) -> dict | None
+
+
+async def handle_synthesize_title(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for synthesize_title."""
+    # Extract prompt from event data (UserPromptSubmit hook)
+    prompt = None
+    if context.event_data:
+        prompt = context.event_data.get("prompt")
+
+    return await synthesize_title(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template_engine=context.template_engine,
+        template=kwargs.get("template"),
+        prompt=prompt,
+    )
+
+
+async def handle_generate_summary(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for generate_summary."""
+    return await generate_summary(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template=kwargs.get("template"),
+        mode=kwargs.get("mode", "clear"),
+        previous_summary=kwargs.get("previous_summary"),
+    )
+
+
+async def handle_generate_handoff(context: ActionContext, **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for generate_handoff.
+
+    Handles mode detection from event_data and previous summary fetching for compact mode.
+    Also supports loading templates from prompts collection via 'prompt' parameter.
+    """
+    # Detect mode from kwargs or event data
+    mode = kwargs.get("mode", "clear")
+
+    # Check if this is a compact event based on event_data
+    COMPACT_EVENT_TYPES = {"pre_compact", "compact"}
+    if context.event_data:
+        raw_event_type = context.event_data.get("event_type") or ""
+        normalized_event_type = str(raw_event_type).strip().lower()
+        if normalized_event_type in COMPACT_EVENT_TYPES:
+            mode = "compact"
+
+    # For compact mode, fetch previous summary for cumulative compression
+    previous_summary = None
+    if mode == "compact":
+        current_session = context.session_manager.get(context.session_id)
+        if current_session:
+            previous_summary = getattr(current_session, "summary_markdown", None)
+            if previous_summary:
+                logger.debug(
+                    f"Compact mode: using previous summary ({len(previous_summary)} chars) "
+                    f"for cumulative compression"
+                )
+
+    # Load template from prompts collection if 'prompt' parameter provided
+    template = kwargs.get("template")
+    prompt_path = kwargs.get("prompt")
+    if prompt_path and not template:
+        try:
+            from gobby.prompts.loader import PromptLoader
+
+            loader = PromptLoader()
+            prompt_template = loader.load(prompt_path)
+            template = prompt_template.content
+            logger.debug(f"Loaded prompt template from: {prompt_path}")
+        except Exception as e:
+            logger.warning(f"Failed to load prompt from {prompt_path}: {e}")
+            # Fall back to inline template or default
+
+    return await generate_handoff(
+        session_manager=context.session_manager,
+        session_id=context.session_id,
+        llm_service=context.llm_service,
+        transcript_processor=context.transcript_processor,
+        template=template,
+        previous_summary=previous_summary,
+        mode=mode,
+    )