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

gobby/workflows/evaluator.py

@@ -348,6 +348,116 @@ class ConditionEvaluator:
 
             allowed_globals["mcp_called"] = _mcp_called
 
+            def _mcp_result_is_null(server: str, tool: str) -> bool:
+                """Check if MCP tool result is null/missing.
+
+                Used in workflow conditions like:
+                    when: "mcp_result_is_null('gobby-tasks', 'suggest_next_task')"
+
+                Args:
+                    server: MCP server name
+                    tool: Tool name
+
+                Returns:
+                    True if the result is null/missing, False if result exists.
+                """
+                variables = context.get("variables", {})
+                if isinstance(variables, dict):
+                    mcp_results = variables.get("mcp_results", {})
+                else:
+                    mcp_results = getattr(variables, "mcp_results", {})
+
+                if not isinstance(mcp_results, dict):
+                    return True  # No results means null
+
+                server_results = mcp_results.get(server, {})
+                if not isinstance(server_results, dict):
+                    return True
+
+                result = server_results.get(tool)
+                return result is None
+
+            allowed_globals["mcp_result_is_null"] = _mcp_result_is_null
+
+            def _mcp_failed(server: str, tool: str) -> bool:
+                """Check if MCP tool call failed.
+
+                Used in workflow conditions like:
+                    when: "mcp_failed('gobby-agents', 'spawn_agent')"
+
+                Args:
+                    server: MCP server name
+                    tool: Tool name
+
+                Returns:
+                    True if the result exists and indicates failure.
+                """
+                variables = context.get("variables", {})
+                if isinstance(variables, dict):
+                    mcp_results = variables.get("mcp_results", {})
+                else:
+                    mcp_results = getattr(variables, "mcp_results", {})
+
+                if not isinstance(mcp_results, dict):
+                    return False  # No results means we can't determine failure
+
+                server_results = mcp_results.get(server, {})
+                if not isinstance(server_results, dict):
+                    return False
+
+                result = server_results.get(tool)
+                if result is None:
+                    return False
+
+                # Check for failure indicators
+                if isinstance(result, dict):
+                    if result.get("success") is False:
+                        return True
+                    if result.get("error"):
+                        return True
+                    if result.get("status") == "failed":
+                        return True
+                return False
+
+            allowed_globals["mcp_failed"] = _mcp_failed
+
+            def _mcp_result_has(server: str, tool: str, field: str, value: Any) -> bool:
+                """Check if MCP tool result has a specific field value.
+
+                Used in workflow conditions like:
+                    when: "mcp_result_has('gobby-tasks', 'wait_for_task', 'timed_out', True)"
+
+                Args:
+                    server: MCP server name
+                    tool: Tool name
+                    field: Field name to check
+                    value: Expected value (supports bool, str, int, float)
+
+                Returns:
+                    True if the field equals the expected value.
+                """
+                variables = context.get("variables", {})
+                if isinstance(variables, dict):
+                    mcp_results = variables.get("mcp_results", {})
+                else:
+                    mcp_results = getattr(variables, "mcp_results", {})
+
+                if not isinstance(mcp_results, dict):
+                    return False
+
+                server_results = mcp_results.get(server, {})
+                if not isinstance(server_results, dict):
+                    return False
+
+                result = server_results.get(tool)
+                if not isinstance(result, dict):
+                    return False
+
+                actual_value = result.get(field)
+                return bool(actual_value == value)
+
+            allowed_globals["mcp_result_has"] = _mcp_result_has
+
             # eval used with restricted allowed_globals for workflow conditions
             # nosec B307: eval is intentional here for DSL evaluation with
             # restricted globals (__builtins__={}) and controlled workflow conditions

gobby/workflows/git_utils.py

@@ -4,8 +4,15 @@ Extracted from actions.py as part of strangler fig decomposition.
 These are pure utility functions with no ActionContext dependency.
 """
 
+from __future__ import annotations
+
 import logging
 import subprocess  # nosec B404 - subprocess needed for git commands
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from gobby.storage.session_tasks import SessionTaskManager
+    from gobby.storage.sessions import LocalSessionManager
 
 logger = logging.getLogger(__name__)
 
@@ -94,3 +101,102 @@ def get_file_changes() -> str:
 
     except Exception:
         return "Unable to determine file changes"
+
+
+def get_dirty_files(project_path: str | None = None) -> set[str]:
+    """
+    Get the set of dirty files from git status --porcelain.
+
+    Excludes .gobby/ files from the result.
+
+    Args:
+        project_path: Path to the project directory
+
+    Returns:
+        Set of dirty file paths (relative to repo root)
+    """
+    if project_path is None:
+        logger.warning(
+            "get_dirty_files: project_path is None, git status will use daemon's cwd "
+            "which may not be the project directory"
+        )
+
+    try:
+        result = subprocess.run(  # nosec B603 B607 - hardcoded git command
+            ["git", "status", "--porcelain"],
+            cwd=project_path,
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+
+        if result.returncode != 0:
+            logger.warning(f"get_dirty_files: git status failed: {result.stderr}")
+            return set()
+
+        dirty_files = set()
+        # Split by newline first, don't strip() the whole string as it removes
+        # the leading space from git status format (e.g., " M file.py")
+        for line in result.stdout.split("\n"):
+            line = line.rstrip()  # Remove trailing whitespace only
+            if not line:
+                continue
+            # Format is "XY filename" or "XY filename -> newname" for renames
+            # Skip the status prefix (first 3 chars: 2 status chars + space)
+            filepath = line[3:].split(" -> ")[0]  # Handle renames
+            # Exclude .gobby/ files
+            if not filepath.startswith(".gobby/"):
+                dirty_files.add(filepath)
+
+        return dirty_files
+
+    except subprocess.TimeoutExpired:
+        logger.warning("get_dirty_files: git status timed out")
+        return set()
+    except FileNotFoundError:
+        logger.warning("get_dirty_files: git not found")
+        return set()
+    except Exception as e:
+        logger.error(f"get_dirty_files: Error running git status: {e}")
+        return set()
+
+
+def get_task_session_liveness(
+    task_id: str,
+    session_task_manager: SessionTaskManager | None,
+    session_manager: LocalSessionManager | None,
+    exclude_session_id: str | None = None,
+) -> bool:
+    """
+    Check if a task is currently being worked on by an active session.
+
+    Args:
+        task_id: The task ID to check
+        session_task_manager: Manager to look up session-task links
+        session_manager: Manager to check session status
+        exclude_session_id: ID of session to exclude from check (e.g. current one)
+
+    Returns:
+        True if an active session (status='active') is linked to this task.
+    """
+    if not session_task_manager or not session_manager:
+        return False
+
+    try:
+        # Get all sessions linked to this task
+        linked_sessions = session_task_manager.get_task_sessions(task_id)
+
+        for link in linked_sessions:
+            session_id = link.get("session_id")
+            if not session_id or session_id == exclude_session_id:
+                continue
+
+            # Check if session is truly active
+            session = session_manager.get(session_id)
+            if session and session.status == "active":
+                return True
+
+        return False
+    except Exception as e:
+        logger.warning(f"get_task_session_liveness: Error checking liveness for {task_id}: {e}")
+        return False

gobby/workflows/hooks.py

@@ -167,3 +167,44 @@ class WorkflowHookHandler:
         except Exception as e:
             logger.error(f"Error handling lifecycle workflow: {e}", exc_info=True)
             return HookResponse(decision="allow")
+
+    def activate_workflow(
+        self,
+        workflow_name: str,
+        session_id: str,
+        project_path: str | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Activate a step-based workflow for a session.
+
+        This is used during session startup for terminal-mode agents that have
+        a workflow_name set. It's a synchronous wrapper around the engine's
+        activate_workflow method.
+
+        Args:
+            workflow_name: Name of the workflow to activate
+            session_id: Session ID to activate for
+            project_path: Optional project path for workflow discovery
+            variables: Optional initial variables to merge with workflow defaults
+
+        Returns:
+            Dict with success status and workflow info
+        """
+        if not self._enabled:
+            return {"success": False, "error": "Workflow engine is disabled"}
+
+        from pathlib import Path
+
+        path = Path(project_path) if project_path else None
+
+        try:
+            return self.engine.activate_workflow(
+                workflow_name=workflow_name,
+                session_id=session_id,
+                project_path=path,
+                variables=variables,
+            )
+        except Exception as e:
+            logger.error(f"Error activating workflow: {e}", exc_info=True)
+            return {"success": False, "error": str(e)}

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/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

@@ -205,6 +205,17 @@ async def memory_recall_relevant(
         # Filter out memories that have already been injected in this session
         new_memories = [m for m in memories if m.id not in injected_ids]
 
+        # Deduplicate by content to avoid showing same content with different IDs
+        # (can happen when same content was stored with different project_ids)
+        seen_content: set[str] = set()
+        unique_memories = []
+        for m in new_memories:
+            normalized = m.content.strip()
+            if normalized not in seen_content:
+                seen_content.add(normalized)
+                unique_memories.append(m)
+        new_memories = unique_memories
+
         if not new_memories:
             logger.debug(
                 f"memory_recall_relevant: All {len(memories)} memories already injected, skipping"
@@ -344,3 +355,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,191 @@
+"""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 visit_List(self, node: ast.List) -> list[Any]:
+        """Handle list literals (e.g., ['a', 'b', 'c'])."""
+        return [self.visit(elt) for elt in node.elts]
+
+    def visit_Tuple(self, node: ast.Tuple) -> tuple[Any, ...]:
+        """Handle tuple literals (e.g., ('a', 'b', 'c'))."""
+        return tuple(self.visit(elt) for elt in node.elts)
+
+    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"))