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

gobby/storage/skills.py

@@ -52,6 +52,11 @@ class Skill:
         - source_type: 'local', 'github', 'url', 'zip', 'filesystem'
         - source_ref: Git ref for updates (branch/tag/commit)
 
+    Hub Tracking:
+        - hub_name: Name of the hub the skill originated from
+        - hub_slug: Slug of the hub the skill originated from
+        - hub_version: Version of the skill as reported by the hub
+
     Gobby-specific:
         - enabled: Toggle skill on/off without removing
         - project_id: NULL for global, else project-scoped
@@ -79,6 +84,11 @@ class Skill:
     source_type: SkillSourceType | None = None
     source_ref: str | None = None
 
+    # Hub Tracking
+    hub_name: str | None = None
+    hub_slug: str | None = None
+    hub_version: str | None = None
+
     # Gobby-specific
     enabled: bool = True
     project_id: str | None = None
@@ -117,6 +127,9 @@ class Skill:
             source_path=row["source_path"],
             source_type=row["source_type"],
             source_ref=row["source_ref"],
+            hub_name=row["hub_name"] if "hub_name" in row.keys() else None,
+            hub_slug=row["hub_slug"] if "hub_slug" in row.keys() else None,
+            hub_version=row["hub_version"] if "hub_version" in row.keys() else None,
             enabled=bool(row["enabled"]),
             project_id=row["project_id"],
             created_at=row["created_at"],
@@ -142,6 +155,9 @@ class Skill:
             "source_path": self.source_path,
             "source_type": self.source_type,
             "source_ref": self.source_ref,
+            "hub_name": self.hub_name,
+            "hub_slug": self.hub_slug,
+            "hub_version": self.hub_version,
             "enabled": self.enabled,
             "project_id": self.project_id,
             "created_at": self.created_at,
@@ -387,6 +403,9 @@ class LocalSkillManager:
         source_path: str | None = None,
         source_type: SkillSourceType | None = None,
         source_ref: str | None = None,
+        hub_name: str | None = None,
+        hub_slug: str | None = None,
+        hub_version: str | None = None,
         enabled: bool = True,
         project_id: str | None = None,
     ) -> Skill:
@@ -404,6 +423,9 @@ class LocalSkillManager:
             source_path: Original file path or URL
             source_type: Source type ('local', 'github', 'url', 'zip', 'filesystem')
             source_ref: Git ref for updates
+            hub_name: Optional hub name
+            hub_slug: Optional hub slug
+            hub_version: Optional hub version
             enabled: Whether skill is active
             project_id: Project scope (None for global)
 
@@ -434,9 +456,9 @@ class LocalSkillManager:
                 INSERT INTO skills (
                     id, name, description, content, version, license,
                     compatibility, allowed_tools, metadata, source_path,
-                    source_type, source_ref, enabled, project_id,
-                    created_at, updated_at
-                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    source_type, source_ref, hub_name, hub_slug, hub_version,
+                    enabled, project_id, created_at, updated_at
+                ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                 """,
                 (
                     skill_id,
@@ -451,6 +473,9 @@ class LocalSkillManager:
                     source_path,
                     source_type,
                     source_ref,
+                    hub_name,
+                    hub_slug,
+                    hub_version,
                     enabled,
                     project_id,
                     now,
@@ -530,6 +555,9 @@ class LocalSkillManager:
         source_path: str | None = _UNSET,
         source_type: SkillSourceType | None = _UNSET,
         source_ref: str | None = _UNSET,
+        hub_name: str | None = _UNSET,
+        hub_slug: str | None = _UNSET,
+        hub_version: str | None = _UNSET,
         enabled: bool | None = None,
     ) -> Skill:
         """Update an existing skill.
@@ -547,6 +575,9 @@ class LocalSkillManager:
             source_path: New source path (use _UNSET to leave unchanged, None to clear)
             source_type: New source type (use _UNSET to leave unchanged, None to clear)
             source_ref: New source ref (use _UNSET to leave unchanged, None to clear)
+            hub_name: New hub name (use _UNSET to leave unchanged, None to clear)
+            hub_slug: New hub slug (use _UNSET to leave unchanged, None to clear)
+            hub_version: New hub version (use _UNSET to leave unchanged, None to clear)
             enabled: New enabled state (optional)
 
         Returns:
@@ -591,6 +622,15 @@ class LocalSkillManager:
         if source_ref is not _UNSET:
             updates.append("source_ref = ?")
             params.append(source_ref)
+        if hub_name is not _UNSET:
+            updates.append("hub_name = ?")
+            params.append(hub_name)
+        if hub_slug is not _UNSET:
+            updates.append("hub_slug = ?")
+            params.append(hub_slug)
+        if hub_version is not _UNSET:
+            updates.append("hub_version = ?")
+            params.append(hub_version)
         if enabled is not None:
             updates.append("enabled = ?")
             params.append(enabled)

gobby/workflows/detection_helpers.py

@@ -7,7 +7,7 @@ and update workflow state variables accordingly.
 """
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from gobby.hooks.events import HookEvent
@@ -44,30 +44,24 @@ def detect_task_claim(
     if not event.data:
         return
 
-    tool_name = event.data.get("tool_name", "")
     tool_input = event.data.get("tool_input", {}) or {}
-    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
-    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
-
-    # Check if this is a gobby-tasks call via MCP proxy
-    # Tool name could be "call_tool" (from legacy) or "mcp__gobby__call_tool" (direct)
-    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
-        return
+    # Use normalized tool_output (adapters normalize tool_result/tool_response)
+    tool_output = event.data.get("tool_output") or {}
 
-    # Check server is gobby-tasks
-    server_name = tool_input.get("server_name", "")
+    # Use normalized MCP fields from adapter layer
+    # Adapters extract these from CLI-specific formats
+    server_name = event.data.get("mcp_server", "")
     if server_name != "gobby-tasks":
         return
 
-    # Check inner tool name
-    inner_tool_name = tool_input.get("tool_name", "")
+    inner_tool_name = event.data.get("mcp_tool", "")
 
     # Handle close_task - clears task_claimed when task is closed
     # Note: Claude Code doesn't include tool_result in post-tool-use hooks, so for CC
     # the workflow state is updated directly in the MCP proxy's close_task function.
     # This detection provides a fallback for CLIs that do report tool results (Gemini/Codex).
     if inner_tool_name == "close_task":
-        tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
+        # tool_output already normalized at top of function
 
         # If no tool output, skip - can't verify success
         # The MCP proxy's close_task handles state clearing for successful closes
@@ -254,6 +248,11 @@ def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
     This enables workflow conditions like:
         when: "mcp_called('gobby-memory', 'recall')"
 
+    Uses normalized fields from adapters:
+    - mcp_server: The MCP server name (normalized from both Claude and Gemini formats)
+    - mcp_tool: The tool name on the server (normalized from both formats)
+    - tool_output: The tool result (normalized from tool_result/tool_response)
+
     Args:
         event: The AFTER_TOOL hook event
         state: Current workflow state (modified in place)
@@ -261,21 +260,36 @@ def detect_mcp_call(event: "HookEvent", state: "WorkflowState") -> None:
     if not event.data:
         return
 
-    tool_name = event.data.get("tool_name", "")
-    tool_input = event.data.get("tool_input", {}) or {}
-    # Claude Code sends "tool_result", but we also check "tool_output" for compatibility
-    tool_output = event.data.get("tool_result") or event.data.get("tool_output") or {}
+    # Use normalized fields from adapter layer
+    # Adapters extract these from CLI-specific formats:
+    # - Claude: tool_input.server_name/tool_name → mcp_server/mcp_tool
+    # - Gemini: mcp_context.server_name/tool_name → mcp_server/mcp_tool
+    server_name = event.data.get("mcp_server", "")
+    inner_tool = event.data.get("mcp_tool", "")
 
-    # Check for MCP proxy call
-    if tool_name not in ("call_tool", "mcp__gobby__call_tool"):
+    if not server_name or not inner_tool:
         return
 
-    server_name = tool_input.get("server_name", "")
-    inner_tool = tool_input.get("tool_name", "")
+    # Use normalized tool_output (adapters normalize tool_result/tool_response)
+    tool_output = event.data.get("tool_output") or {}
 
-    if not server_name or not inner_tool:
-        return
+    _track_mcp_call(state, server_name, inner_tool, tool_output)
+
+
+def _track_mcp_call(
+    state: "WorkflowState",
+    server_name: str,
+    inner_tool: str,
+    tool_output: dict[str, Any] | Any,
+) -> None:
+    """Track a successful MCP call in workflow state.
 
+    Args:
+        state: Current workflow state (modified in place)
+        server_name: MCP server name (e.g., "gobby-sessions")
+        inner_tool: Tool name on the server (e.g., "get_current_session")
+        tool_output: Tool output to check for errors
+    """
     # Check if call succeeded (skip tracking failed calls)
     if isinstance(tool_output, dict):
         if tool_output.get("error") or tool_output.get("status") == "error":

gobby/workflows/enforcement/blocking.py

@@ -5,6 +5,7 @@ Provides configurable tool blocking based on workflow state and conditions.
 
 from __future__ import annotations
 
+import json
 import logging
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
@@ -241,7 +242,18 @@ async def block_tools(
                 if mcp_key in mcp_tools:
                     rule_matches = True
                     # For MCP tools, the actual arguments are in tool_input.arguments
-                    mcp_tool_args = tool_input.get("arguments", {}) or {}
+                    # Arguments may be a JSON string (Claude Code serialization) or dict
+                    raw_args = tool_input.get("arguments")
+                    if isinstance(raw_args, str):
+                        try:
+                            parsed = json.loads(raw_args)
+                            mcp_tool_args = parsed if isinstance(parsed, dict) else {}
+                        except (json.JSONDecodeError, TypeError):
+                            mcp_tool_args = {}
+                    elif isinstance(raw_args, dict):
+                        mcp_tool_args = raw_args
+                    else:
+                        mcp_tool_args = {}
 
         if not rule_matches:
             continue

gobby/workflows/engine.py

@@ -494,3 +494,96 @@ 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 workflow default variables with passed-in variables
+        merged_variables = dict(definition.variables)
+        if variables:
+            merged_variables.update(variables)
+
+        # 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/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__}")