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

gobby/workflows/lifecycle_evaluator.py

@@ -439,6 +439,7 @@ async def evaluate_all_lifecycle_workflows(
     detect_plan_mode_fn: Any,
     check_premature_stop_fn: Any,
     context_data: dict[str, Any] | None = None,
+    detect_plan_mode_from_context_fn: Any | None = None,
 ) -> HookResponse:
     """
     Discover and evaluate all lifecycle workflows for the given event.
@@ -453,9 +454,10 @@ async def evaluate_all_lifecycle_workflows(
         action_executor: Action executor for running actions
         evaluator: Condition evaluator
         detect_task_claim_fn: Function to detect task claims
-        detect_plan_mode_fn: Function to detect plan mode
+        detect_plan_mode_fn: Function to detect plan mode (from tool calls)
         check_premature_stop_fn: Async function to check premature stop
         context_data: Optional context data passed between actions
+        detect_plan_mode_from_context_fn: Function to detect plan mode from system reminders
 
     Returns:
         Merged HookResponse with combined context and first non-allow decision.
@@ -594,6 +596,21 @@ async def evaluate_all_lifecycle_workflows(
             detect_plan_mode_fn(event, state)
             state_manager.save_state(state)
 
+    # Detect plan mode from system reminders for BEFORE_AGENT events
+    # This catches plan mode when user enters via UI (not via EnterPlanMode tool)
+    if event.event_type == HookEventType.BEFORE_AGENT and detect_plan_mode_from_context_fn:
+        session_id = event.metadata.get("_platform_session_id")
+        if session_id:
+            state = state_manager.get_state(session_id)
+            if state is None:
+                state = WorkflowState(
+                    session_id=session_id,
+                    workflow_name="__lifecycle__",
+                    step="",
+                )
+            detect_plan_mode_from_context_fn(event, state)
+            state_manager.save_state(state)
+
     # Check for premature stop in active step workflows on STOP events
     if event.event_type == HookEventType.STOP:
         premature_response = await check_premature_stop_fn(event, context_data)
@@ -610,4 +627,15 @@ async def evaluate_all_lifecycle_workflows(
         reason=final_reason,
         context="\n\n".join(all_context) if all_context else None,
         system_message=final_system_message,
+        metadata={
+            "discovered_workflows": [
+                {
+                    "name": w.name,
+                    "priority": w.priority,
+                    "is_project": w.is_project,
+                    "path": str(w.path),
+                }
+                for w in workflows
+            ]
+        },
     )

gobby/workflows/llm_actions.py

@@ -68,3 +68,33 @@ async def call_llm(
     except Exception as e:
         logger.error(f"call_llm: Failed: {e}")
         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_call_llm(context: "ActionContext", **kwargs: Any) -> dict[str, Any] | None:
+    """ActionHandler wrapper for call_llm."""
+    if context.session_manager is None:
+        return {"error": "Session manager not available"}
+
+    session = context.session_manager.get(context.session_id)
+    if session is None:
+        return {"error": f"Session not found: {context.session_id}"}
+
+    return await call_llm(
+        llm_service=context.llm_service,
+        template_engine=context.template_engine,
+        state=context.state,
+        session=session,
+        prompt=kwargs.get("prompt"),
+        output_as=kwargs.get("output_as"),
+        **{k: v for k, v in kwargs.items() if k not in ("prompt", "output_as")},
+    )

gobby/workflows/loader.py

@@ -193,6 +193,7 @@ class WorkflowLoader:
             return self._discovery_cache[cache_key]
 
         discovered: dict[str, DiscoveredWorkflow] = {}  # name -> workflow (for shadowing)
+        failed: dict[str, str] = {}  # name -> error message for failed workflows
 
         # 1. Scan global lifecycle directory first (will be shadowed by project)
         for global_dir in self.global_dirs:
@@ -201,7 +202,14 @@ class WorkflowLoader:
         # 2. Scan project lifecycle directory (shadows global)
         if project_path:
             project_dir = Path(project_path) / ".gobby" / "workflows" / "lifecycle"
-            self._scan_directory(project_dir, is_project=True, discovered=discovered)
+            self._scan_directory(project_dir, is_project=True, discovered=discovered, failed=failed)
+
+            # Log errors when project workflow fails but global exists (failed shadowing)
+            for name, error in failed.items():
+                if name in discovered and not discovered[name].is_project:
+                    logger.error(
+                        f"Project workflow '{name}' failed to load, using global instead: {error}"
+                    )
 
         # 3. Filter to lifecycle workflows only
         lifecycle_workflows = [w for w in discovered.values() if w.definition.type == "lifecycle"]
@@ -225,6 +233,7 @@ class WorkflowLoader:
         directory: Path,
         is_project: bool,
         discovered: dict[str, DiscoveredWorkflow],
+        failed: dict[str, str] | None = None,
     ) -> None:
         """
         Scan a directory for workflow YAML files and add to discovered dict.
@@ -233,6 +242,7 @@ class WorkflowLoader:
             directory: Directory to scan
             is_project: Whether this is a project directory (for shadowing)
             discovered: Dict to update (name -> DiscoveredWorkflow)
+            failed: Optional dict to track failed workflows (name -> error message)
         """
         if not directory.exists():
             return
@@ -258,6 +268,8 @@ class WorkflowLoader:
                             data = self._merge_workflows(parent.model_dump(), data)
                     except ValueError as e:
                         logger.warning(f"Skipping workflow {name}: {e}")
+                        if failed is not None:
+                            failed[name] = str(e)
                         continue
 
                 definition = WorkflowDefinition(**data)
@@ -267,6 +279,10 @@ class WorkflowLoader:
                 if definition.settings and "priority" in definition.settings:
                     priority = definition.settings["priority"]
 
+                # Log successful shadowing when project workflow overrides global
+                if name in discovered and is_project and not discovered[name].is_project:
+                    logger.info(f"Project workflow '{name}' shadows global workflow")
+
                 # Project workflows shadow global (overwrite in dict)
                 # Global is scanned first, so project overwrites
                 discovered[name] = DiscoveredWorkflow(
@@ -279,6 +295,8 @@ class WorkflowLoader:
 
             except Exception as e:
                 logger.warning(f"Failed to load workflow from {yaml_path}: {e}")
+                if failed is not None:
+                    failed[name] = str(e)
 
     def clear_cache(self) -> None:
         """
@@ -288,11 +306,6 @@ class WorkflowLoader:
         self._cache.clear()
         self._discovery_cache.clear()
 
-    def clear_discovery_cache(self) -> None:
-        """Clear the discovery cache. Call when workflows may have changed."""
-        # Deprecated: use clear_cache instead to clear everything
-        self.clear_cache()
-
     def validate_workflow_for_agent(
         self,
         workflow_name: str,

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

@@ -270,3 +270,157 @@ def reset_memory_injection_tracking(state: Any | None = None) -> dict[str, Any]:
         logger.info(f"reset_memory_injection_tracking: Cleared {cleared_count} injected memory IDs")
 
     return {"success": True, "cleared": cleared_count}
+
+
+async def memory_extract(
+    session_manager: Any,
+    session_id: str,
+    llm_service: Any,
+    memory_manager: Any,
+    transcript_processor: Any | None = None,
+    min_importance: float = 0.7,
+    max_memories: int = 5,
+    dry_run: bool = False,
+) -> dict[str, Any] | None:
+    """Extract memories from a session transcript.
+
+    Uses LLM analysis to identify high-value, reusable knowledge from
+    session transcripts and stores them as memories.
+
+    Args:
+        session_manager: The session manager instance
+        session_id: Current session ID
+        llm_service: LLM service for analysis
+        memory_manager: Memory manager for storage
+        transcript_processor: Optional transcript processor
+        min_importance: Minimum importance threshold (0.0-1.0)
+        max_memories: Maximum memories to extract
+        dry_run: If True, don't store memories
+
+    Returns:
+        Dict with extracted_count and memory details, or error
+    """
+    if not memory_manager:
+        return {"error": "Memory Manager not available"}
+
+    if not memory_manager.config.enabled:
+        logger.debug("memory_extract: Memory system disabled")
+        return None
+
+    if not llm_service:
+        return {"error": "LLM service not available"}
+
+    try:
+        from gobby.memory.extractor import SessionMemoryExtractor
+
+        extractor = SessionMemoryExtractor(
+            memory_manager=memory_manager,
+            session_manager=session_manager,
+            llm_service=llm_service,
+            transcript_processor=transcript_processor,
+        )
+
+        candidates = await extractor.extract(
+            session_id=session_id,
+            min_importance=min_importance,
+            max_memories=max_memories,
+            dry_run=dry_run,
+        )
+
+        if not candidates:
+            logger.debug(f"memory_extract: No memories extracted from session {session_id}")
+            return {"extracted_count": 0, "memories": []}
+
+        logger.info(
+            f"memory_extract: Extracted {len(candidates)} memories from session {session_id}"
+        )
+
+        return {
+            "extracted_count": len(candidates),
+            "memories": [c.to_dict() for c in candidates],
+            "dry_run": dry_run,
+        }
+
+    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)