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

gobby/workflows/engine.py

@@ -494,3 +494,99 @@ class WorkflowEngine:
     def _detect_mcp_call(self, event: HookEvent, state: WorkflowState) -> None:
         """Track MCP tool calls by server/tool for workflow conditions."""
         detect_mcp_call(event, state)
+
+    def activate_workflow(
+        self,
+        workflow_name: str,
+        session_id: str,
+        project_path: Path | None = None,
+        variables: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """
+        Activate a step-based workflow for a session.
+
+        This is used internally during session startup for terminal-mode agents
+        that have a workflow_name set. It creates the initial workflow state.
+
+        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
+        """
+        # Load workflow
+        definition = self.loader.load_workflow(workflow_name, project_path)
+        if not definition:
+            logger.warning(f"Workflow '{workflow_name}' not found for auto-activation")
+            return {"success": False, "error": f"Workflow '{workflow_name}' not found"}
+
+        if definition.type == "lifecycle":
+            logger.debug(f"Skipping auto-activation of lifecycle workflow '{workflow_name}'")
+            return {
+                "success": False,
+                "error": f"Workflow '{workflow_name}' is lifecycle type (auto-runs on events)",
+            }
+
+        # Check for existing step workflow
+        existing = self.state_manager.get_state(session_id)
+        if existing and existing.workflow_name != "__lifecycle__":
+            # Check if existing is lifecycle type
+            existing_def = self.loader.load_workflow(existing.workflow_name, project_path)
+            if not existing_def or existing_def.type != "lifecycle":
+                logger.warning(
+                    f"Session {session_id} already has workflow '{existing.workflow_name}' active"
+                )
+                return {
+                    "success": False,
+                    "error": f"Session already has workflow '{existing.workflow_name}' active",
+                }
+
+        # Determine initial step - fail fast if no steps defined
+        if not definition.steps:
+            logger.error(f"Workflow '{workflow_name}' has no steps defined")
+            return {
+                "success": False,
+                "error": f"Workflow '{workflow_name}' has no steps defined",
+            }
+        step = definition.steps[0].name
+
+        # Merge variables: preserve existing lifecycle variables, then apply workflow declarations
+        # Priority: existing state < workflow defaults < passed-in variables
+        # This preserves lifecycle variables (like unlocked_tools) that the step workflow doesn't declare
+        merged_variables = dict(existing.variables) if existing else {}
+        merged_variables.update(definition.variables)  # Override with workflow-declared defaults
+        if variables:
+            merged_variables.update(variables)  # Override with passed-in values
+
+        # Create state
+        state = WorkflowState(
+            session_id=session_id,
+            workflow_name=workflow_name,
+            step=step,
+            step_entered_at=datetime.now(UTC),
+            step_action_count=0,
+            total_action_count=0,
+            artifacts={},
+            observations=[],
+            reflection_pending=False,
+            context_injected=False,
+            variables=merged_variables,
+            task_list=None,
+            current_task_index=0,
+            files_modified_this_task=0,
+        )
+
+        self.state_manager.save_state(state)
+        logger.info(f"Auto-activated workflow '{workflow_name}' for session {session_id}")
+
+        return {
+            "success": True,
+            "session_id": session_id,
+            "workflow": workflow_name,
+            "step": step,
+            "steps": [s.name for s in definition.steps],
+            "variables": merged_variables,
+        }

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/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/lifecycle_evaluator.py

@@ -636,6 +636,7 @@ async def evaluate_all_lifecycle_workflows(
                     "path": str(w.path),
                 }
                 for w in workflows
-            ]
+            ],
+            "workflow_variables": context_data,
         },
     )

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"

gobby/workflows/safe_evaluator.py

@@ -178,6 +178,14 @@ class SafeExpressionEvaluator(ast.NodeVisitor):
         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/summary_actions.py

@@ -22,6 +22,9 @@ logger = logging.getLogger(__name__)
 def format_turns_for_llm(turns: list[dict[str, Any]]) -> str:
     """Format transcript turns for LLM analysis.
 
+    Handles both Claude Code format (nested message.role/content) and
+    Gemini CLI format (flat type/role/content).
+
     Args:
         turns: List of transcript turn dicts
 
@@ -30,51 +33,108 @@ def format_turns_for_llm(turns: list[dict[str, Any]]) -> str:
     """
     formatted: list[str] = []
     for i, turn in enumerate(turns):
-        message = turn.get("message", {})
-        role = message.get("role", "unknown")
-        content = message.get("content", "")
-
-        # Assistant messages have content as array of blocks
-        if isinstance(content, list):
-            text_parts: list[str] = []
-            for block in content:
-                if isinstance(block, dict):
-                    if block.get("type") == "text":
-                        text_parts.append(block.get("text", ""))
-                    elif block.get("type") == "thinking":
-                        text_parts.append(f"[Thinking: {block.get('thinking', '')}]")
-                    elif block.get("type") == "tool_use":
-                        text_parts.append(f"[Tool: {block.get('name', 'unknown')}]")
-                    elif block.get("type") == "tool_result":
-                        result_content = block.get("content", "")
-                        # Extract text from list of content blocks if needed
-                        if isinstance(result_content, list):
-                            extracted = []
-                            for item in result_content:
-                                if isinstance(item, dict):
-                                    extracted.append(
-                                        item.get("text", "") or item.get("content", "")
-                                    )
-                                else:
-                                    extracted.append(str(item))
-                            result_content = " ".join(extracted)
-                        content_str = str(result_content)
-                        preview = content_str[:100]
-                        suffix = "..." if len(content_str) > 100 else ""
-                        text_parts.append(f"[Result: {preview}{suffix}]")
-            content = " ".join(text_parts)
+        # Detect format: Gemini CLI uses "type" field, Claude uses nested "message"
+        event_type = turn.get("type")
+
+        if event_type:
+            # Gemini CLI format: flat structure with type field
+            role, content = _format_gemini_turn(turn, event_type)
+            if role is None:
+                continue  # Skip non-displayable events
+        else:
+            # Claude Code format: nested message structure
+            role, content = _format_claude_turn(turn)
 
         formatted.append(f"[Turn {i + 1} - {role}]: {content}")
 
     return "\n\n".join(formatted)
 
 
+def _format_gemini_turn(turn: dict[str, Any], event_type: str) -> tuple[str | None, str]:
+    """Format a Gemini CLI turn.
+
+    Returns:
+        Tuple of (role, formatted_content) or (None, "") if should skip
+    """
+    if event_type == "message":
+        role = turn.get("role", "unknown")
+        if role == "model":
+            role = "assistant"
+        content = turn.get("content", "")
+        if isinstance(content, list):
+            content = " ".join(str(part) for part in content)
+        return role, str(content)
+
+    elif event_type == "tool_use":
+        tool_name = turn.get("tool_name") or turn.get("function_name", "unknown")
+        params = turn.get("parameters") or turn.get("args", {})
+        param_preview = str(params)[:100] if params else ""
+        return "assistant", f"[Tool: {tool_name}] {param_preview}"
+
+    elif event_type == "tool_result":
+        tool_name = turn.get("tool_name", "")
+        output = turn.get("output") or turn.get("result", "")
+        output_str = str(output)
+        preview = output_str[:100]
+        suffix = "..." if len(output_str) > 100 else ""
+        return "tool", f"[Result{' from ' + tool_name if tool_name else ''}]: {preview}{suffix}"
+
+    elif event_type in ("init", "result"):
+        # Skip initialization and final result events
+        return None, ""
+
+    else:
+        # Unknown type, try to extract something
+        content = turn.get("content", turn.get("message", ""))
+        return "unknown", str(content)[:200]
+
+
+def _format_claude_turn(turn: dict[str, Any]) -> tuple[str, str]:
+    """Format a Claude Code turn with nested message structure."""
+    message = turn.get("message", {})
+    role = message.get("role", "unknown")
+    content = message.get("content", "")
+
+    # Assistant messages have content as array of blocks
+    if isinstance(content, list):
+        text_parts: list[str] = []
+        for block in content:
+            if isinstance(block, dict):
+                if block.get("type") == "text":
+                    text_parts.append(block.get("text", ""))
+                elif block.get("type") == "thinking":
+                    text_parts.append(f"[Thinking: {block.get('thinking', '')}]")
+                elif block.get("type") == "tool_use":
+                    text_parts.append(f"[Tool: {block.get('name', 'unknown')}]")
+                elif block.get("type") == "tool_result":
+                    result_content = block.get("content", "")
+                    # Extract text from list of content blocks if needed
+                    if isinstance(result_content, list):
+                        extracted = []
+                        for item in result_content:
+                            if isinstance(item, dict):
+                                extracted.append(item.get("text", "") or item.get("content", ""))
+                            else:
+                                extracted.append(str(item))
+                        result_content = " ".join(extracted)
+                    content_str = str(result_content)
+                    preview = content_str[:100]
+                    suffix = "..." if len(content_str) > 100 else ""
+                    text_parts.append(f"[Result: {preview}{suffix}]")
+        content = " ".join(text_parts)
+
+    return role, str(content)
+
+
 def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
     """Extract the last TodoWrite tool call's todos list from transcript.
 
     Scans turns in reverse to find the most recent TodoWrite tool call
     and formats it as a markdown checklist.
 
+    Handles both Claude Code format (nested message.content) and
+    Gemini CLI format (flat type/tool_name/parameters).
+
     Args:
         turns: List of transcript turns
 
@@ -82,6 +142,16 @@ def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
         Formatted markdown string with todo list, or empty string if not found
     """
     for turn in reversed(turns):
+        # Check Gemini CLI format: flat structure with type="tool_use"
+        event_type = turn.get("type")
+        if event_type == "tool_use":
+            tool_name = turn.get("tool_name") or turn.get("function_name", "")
+            if tool_name == "TodoWrite":
+                tool_input = turn.get("parameters") or turn.get("args") or turn.get("input", {})
+                todos = tool_input.get("todos", [])
+                return _format_todos(todos)
+
+        # Check Claude Code format: nested message.content
         message = turn.get("message", {})
         content = message.get("content", [])
 
@@ -91,29 +161,32 @@ def extract_todowrite_state(turns: list[dict[str, Any]]) -> str:
                     if block.get("name") == "TodoWrite":
                         tool_input = block.get("input", {})
                         todos = tool_input.get("todos", [])
+                        return _format_todos(todos)
 
-                        if not todos:
-                            return ""
+    return ""
 
-                        # Format as markdown checklist
-                        lines: list[str] = []
-                        for todo in todos:
-                            content_text = todo.get("content", "")
-                            status = todo.get("status", "pending")
 
-                            # Map status to checkbox style
-                            if status == "completed":
-                                checkbox = "[x]"
-                            elif status == "in_progress":
-                                checkbox = "[>]"
-                            else:
-                                checkbox = "[ ]"
+def _format_todos(todos: list[dict[str, Any]]) -> str:
+    """Format todos list as markdown checklist."""
+    if not todos:
+        return ""
 
-                            lines.append(f"- {checkbox} {content_text}")
+    lines: list[str] = []
+    for todo in todos:
+        content_text = todo.get("content", "")
+        status = todo.get("status", "pending")
 
-                        return "\n".join(lines)
+        # Map status to checkbox style
+        if status == "completed":
+            checkbox = "[x]"
+        elif status == "in_progress":
+            checkbox = "[>]"
+        else:
+            checkbox = "[ ]"
 
-    return ""
+        lines.append(f"- {checkbox} {content_text}")
+
+    return "\n".join(lines)
 
 
 async def synthesize_title(

{gobby-0.2.7.dist-info → gobby-0.2.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gobby
-Version: 0.2.7
+Version: 0.2.9
 Summary: A local-first daemon to unify your AI coding tools. Session tracking and handoffs across Claude Code, Gemini CLI, and Codex. An MCP proxy that discovers tools without flooding context. Task management with dependencies, validation, and TDD expansion. Agent spawning and worktree orchestration. Persistent memory, extensible workflows, and hooks.
 Author-email: Josh Wilhelmi <josh@gobby.ai>
 License-Expression: MIT