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

gobby/mcp_proxy/registries.py

@@ -143,6 +143,7 @@ def setup_internal_registries(
 
     workflows_registry = create_workflows_registry(
         session_manager=local_session_manager,
+        db=getattr(local_session_manager, "db", None) if local_session_manager else None,
     )
     manager.add_registry(workflows_registry)
     logger.debug("Workflows registry initialized")
@@ -281,6 +282,19 @@ def setup_internal_registries(
     else:
         logger.debug("Skills registry not initialized: task_manager is None")
 
+    # Initialize artifacts registry using the existing database from task_manager
+    if task_manager is not None:
+        from gobby.mcp_proxy.tools.artifacts import create_artifacts_registry
+
+        artifacts_registry = create_artifacts_registry(
+            db=task_manager.db,
+            session_manager=local_session_manager,
+        )
+        manager.add_registry(artifacts_registry)
+        logger.debug("Artifacts registry initialized")
+    else:
+        logger.debug("Artifacts registry not initialized: task_manager is None")
+
     logger.info(f"Internal registries initialized: {len(manager)} registries")
     return manager
 

gobby/mcp_proxy/services/recommendation.py

@@ -15,22 +15,6 @@ logger = logging.getLogger("gobby.mcp.server")
 # Search mode type
 SearchMode = Literal["llm", "semantic", "hybrid"]
 
-DEFAULT_HYBRID_RERANK_PROMPT = """Re-rank the following tools for the task: "{task_description}"
-
-Candidates:
-{candidate_list}
-
-Select the best {top_k} tools. Return JSON:
-{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
-
-DEFAULT_LLM_PROMPT = """Recommend tools for the task: "{task_description}"
-
-Available Servers:
-{available_servers}
-
-Return JSON:
-{{"recommendations": [{{"server": "...", "tool": "...", "reason": "..."}}]}}"""
-
 
 class RecommendationService:
     """Service for recommending tools."""
@@ -49,10 +33,6 @@ class RecommendationService:
         self._project_id = project_id
         self._config = config
         self._loader = PromptLoader()
-        self._loader.register_fallback(
-            "features/recommend_hybrid", lambda: DEFAULT_HYBRID_RERANK_PROMPT
-        )
-        self._loader.register_fallback("features/recommend_llm", lambda: DEFAULT_LLM_PROMPT)
 
     def _get_config(self) -> RecommendToolsConfig:
         """Get config with fallback to defaults."""
@@ -181,10 +161,7 @@ class RecommendationService:
                 "candidate_list": candidate_list,
                 "top_k": top_k,
             }
-            try:
-                prompt = self._loader.render(prompt_path, context)
-            except Exception:
-                prompt = DEFAULT_HYBRID_RERANK_PROMPT.format(**context)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)
@@ -223,10 +200,7 @@ class RecommendationService:
                 "task_description": task_description,
                 "available_servers": ", ".join(available_servers),
             }
-            try:
-                prompt = self._loader.render(prompt_path, context)
-            except Exception:
-                prompt = DEFAULT_LLM_PROMPT.format(**context)
+            prompt = self._loader.render(prompt_path, context)
 
             provider = self._llm_service.get_default_provider()
             response = await provider.generate_text(prompt)

gobby/mcp_proxy/tools/artifacts.py

@@ -19,11 +19,11 @@ from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 
 if TYPE_CHECKING:
     from gobby.storage.artifacts import LocalArtifactManager
-    from gobby.storage.database import LocalDatabase
+    from gobby.storage.database import DatabaseProtocol
 
 
 def create_artifacts_registry(
-    db: LocalDatabase | None = None,
+    db: DatabaseProtocol | None = None,
     artifact_manager: LocalArtifactManager | None = None,
     session_manager: Any | None = None,
 ) -> InternalToolRegistry:
@@ -31,7 +31,7 @@ def create_artifacts_registry(
     Create an artifacts tool registry with all artifact-related tools.
 
     Args:
-        db: LocalDatabase instance (used to create artifact_manager if not provided)
+        db: DatabaseProtocol instance (used to create artifact_manager if not provided)
         artifact_manager: LocalArtifactManager instance
         session_manager: Session manager for resolving session references
 

gobby/mcp_proxy/tools/task_readiness.py

@@ -14,6 +14,7 @@ from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.storage.sessions import LocalSessionManager
 from gobby.storage.tasks import TaskNotFoundError
 from gobby.utils.project_context import get_project_context
 from gobby.workflows.state_manager import WorkflowStateManager
@@ -227,6 +228,7 @@ def create_readiness_registry(
 
     # Create workflow state manager for session_task scoping
     workflow_state_manager = WorkflowStateManager(task_manager.db)
+    session_manager = LocalSessionManager(task_manager.db)
 
     # --- list_ready_tasks ---
 
@@ -376,7 +378,16 @@ def create_readiness_registry(
 
         # Auto-scope to session_task if session_id is provided and parent_task_id is not set
         if session_id and not parent_task_id:
-            workflow_state = workflow_state_manager.get_state(session_id)
+            # Resolve session_id from #N format to UUID
+            try:
+                resolved_session_id = session_manager.resolve_session_reference(
+                    session_id, project_id
+                )
+            except Exception as e:
+                logger.warning(f"Could not resolve session_id '{session_id}': {e}")
+                resolved_session_id = session_id
+
+            workflow_state = workflow_state_manager.get_state(resolved_session_id)
             if workflow_state:
                 session_task = workflow_state.variables.get("session_task")
                 if session_task and session_task != "*":
@@ -395,6 +406,19 @@ def create_readiness_registry(
             ready_tasks = _get_ready_descendants(
                 task_manager, parent_task_id, task_type, project_id
             )
+            # If no ready descendants, check if the parent task itself is ready
+            # This handles the case where session_task is a leaf task with no children
+            if not ready_tasks:
+                parent_task = task_manager.get_task(parent_task_id)
+                if parent_task and parent_task.status == "open":
+                    # Check if it matches task_type filter
+                    if task_type is None or parent_task.task_type == task_type:
+                        # Check if task is ready by seeing if it appears in ready list
+                        ready_check = task_manager.list_ready_tasks(
+                            project_id=project_id, limit=200
+                        )
+                        if any(t.id == parent_task_id for t in ready_check):
+                            ready_tasks = [parent_task]
         else:
             ready_tasks = task_manager.list_ready_tasks(
                 task_type=task_type, limit=50, project_id=project_id
@@ -492,7 +516,7 @@ def create_readiness_registry(
             "score": best_score,
             "reason": f"Selected because: {', '.join(reasons) if reasons else 'best available option'}",
             "alternatives": [
-                {"ref": t.to_brief()["ref"], "title": t.title, "score": s}
+                {"ref": t.to_brief().get("ref", t.id), "title": t.title, "score": s}
                 for t, s, _, _ in scored[1:4]  # Show top 3 alternatives
             ],
             "recommended_skills": recommended_skills,
@@ -525,10 +549,9 @@ def create_readiness_registry(
                 },
                 "session_id": {
                     "type": "string",
-                    "description": "Your session ID (from system context). Used to auto-scope suggestions based on workflow's session_task variable.",
+                    "description": "Your session ID (from system context). When provided, auto-scopes suggestions based on workflow's session_task variable.",
                 },
             },
-            "required": ["session_id"],
         },
         func=suggest_next_task,
     )

gobby/mcp_proxy/tools/workflows/__init__.py

@@ -0,0 +1,266 @@
+"""
+Internal MCP tools for Gobby Workflow System.
+
+Exposes functionality for:
+- get_workflow: Get details about a specific workflow definition
+- list_workflows: Discover available workflow definitions
+- activate_workflow: Start a step-based workflow (supports initial variables)
+- end_workflow: Complete/terminate active workflow
+- get_workflow_status: Get current workflow state
+- request_step_transition: Request transition to a different step
+- mark_artifact_complete: Register an artifact as complete
+- set_variable: Set a workflow variable for the session
+- get_variable: Get workflow variable(s) for the session
+- import_workflow: Import a workflow from a file path
+- reload_cache: Clear the workflow loader cache to pick up file changes
+- close_terminal: Agent self-termination
+
+These tools are registered with the InternalToolRegistry and accessed
+via the downstream proxy pattern (call_tool, list_tools, get_tool_schema).
+"""
+
+from typing import Any
+
+from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.mcp_proxy.tools.workflows._artifacts import (
+    get_variable,
+    mark_artifact_complete,
+    set_variable,
+)
+from gobby.mcp_proxy.tools.workflows._import import import_workflow, reload_cache
+from gobby.mcp_proxy.tools.workflows._lifecycle import (
+    activate_workflow,
+    end_workflow,
+    request_step_transition,
+)
+from gobby.mcp_proxy.tools.workflows._query import (
+    get_workflow,
+    get_workflow_status,
+    list_workflows,
+)
+from gobby.mcp_proxy.tools.workflows._terminal import close_terminal
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.utils.project_context import get_workflow_project_path
+from gobby.workflows.loader import WorkflowLoader
+from gobby.workflows.state_manager import WorkflowStateManager
+
+__all__ = [
+    "create_workflows_registry",
+    "get_workflow_project_path",
+]
+
+
+def create_workflows_registry(
+    loader: WorkflowLoader | None = None,
+    state_manager: WorkflowStateManager | None = None,
+    session_manager: LocalSessionManager | None = None,
+    db: DatabaseProtocol | None = None,
+) -> InternalToolRegistry:
+    """
+    Create a workflow tool registry with all workflow-related tools.
+
+    Args:
+        loader: WorkflowLoader instance
+        state_manager: WorkflowStateManager instance (created from db if not provided)
+        session_manager: LocalSessionManager instance (created from db if not provided)
+        db: Database instance for creating default managers
+
+    Returns:
+        InternalToolRegistry with workflow tools registered
+
+    Note:
+        If db is None and state_manager/session_manager are not provided,
+        tools requiring database access will return errors when called.
+    """
+    _db = db
+    _loader = loader or WorkflowLoader()
+
+    # Create default managers only if db is provided
+    if state_manager is not None:
+        _state_manager = state_manager
+    elif _db is not None:
+        _state_manager = WorkflowStateManager(_db)
+    else:
+        _state_manager = None
+
+    if session_manager is not None:
+        _session_manager = session_manager
+    elif _db is not None:
+        _session_manager = LocalSessionManager(_db)
+    else:
+        _session_manager = None
+
+    registry = InternalToolRegistry(
+        name="gobby-workflows",
+        description="Workflow management - list, activate, status, transition, end",
+    )
+
+    @registry.tool(
+        name="get_workflow",
+        description="Get details about a specific workflow definition.",
+    )
+    def _get_workflow(
+        name: str,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        return get_workflow(_loader, name, project_path)
+
+    @registry.tool(
+        name="list_workflows",
+        description="List available workflow definitions from project and global directories.",
+    )
+    def _list_workflows(
+        project_path: str | None = None,
+        workflow_type: str | None = None,
+        global_only: bool = False,
+    ) -> dict[str, Any]:
+        return list_workflows(_loader, project_path, workflow_type, global_only)
+
+    @registry.tool(
+        name="activate_workflow",
+        description="Activate a step-based workflow for the current session. Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _activate_workflow(
+        name: str,
+        session_id: str | None = None,
+        initial_step: str | None = None,
+        variables: dict[str, Any] | None = None,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None or _db is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return activate_workflow(
+            _loader,
+            _state_manager,
+            _session_manager,
+            _db,
+            name,
+            session_id,
+            initial_step,
+            variables,
+            project_path,
+        )
+
+    @registry.tool(
+        name="end_workflow",
+        description="End the currently active step-based workflow. Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _end_workflow(
+        session_id: str | None = None,
+        reason: str | None = None,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return end_workflow(
+            _loader, _state_manager, _session_manager, session_id, reason, project_path
+        )
+
+    @registry.tool(
+        name="get_workflow_status",
+        description="Get current workflow step and state. Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _get_workflow_status(session_id: str | None = None) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return get_workflow_status(_state_manager, _session_manager, session_id)
+
+    @registry.tool(
+        name="request_step_transition",
+        description="Request transition to a different step. Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _request_step_transition(
+        to_step: str,
+        reason: str | None = None,
+        session_id: str | None = None,
+        force: bool = False,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return request_step_transition(
+            _loader,
+            _state_manager,
+            _session_manager,
+            to_step,
+            reason,
+            session_id,
+            force,
+            project_path,
+        )
+
+    @registry.tool(
+        name="mark_artifact_complete",
+        description="Register an artifact as complete (plan, spec, etc.). Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _mark_artifact_complete(
+        artifact_type: str,
+        file_path: str,
+        session_id: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return mark_artifact_complete(
+            _state_manager, _session_manager, artifact_type, file_path, session_id
+        )
+
+    @registry.tool(
+        name="set_variable",
+        description="Set a workflow variable for the current session (session-scoped, not persisted to YAML). Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _set_variable(
+        name: str,
+        value: str | int | float | bool | None,
+        session_id: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None or _db is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return set_variable(_state_manager, _session_manager, _db, name, value, session_id)
+
+    @registry.tool(
+        name="get_variable",
+        description="Get workflow variable(s) for the current session. Accepts #N, N, UUID, or prefix for session_id.",
+    )
+    def _get_variable(
+        name: str | None = None,
+        session_id: str | None = None,
+    ) -> dict[str, Any]:
+        if _state_manager is None or _session_manager is None:
+            return {"success": False, "error": "Workflow tools require database connection"}
+        return get_variable(_state_manager, _session_manager, name, session_id)
+
+    @registry.tool(
+        name="import_workflow",
+        description="Import a workflow from a file path into the project or global directory.",
+    )
+    def _import_workflow(
+        source_path: str,
+        workflow_name: str | None = None,
+        is_global: bool = False,
+        project_path: str | None = None,
+    ) -> dict[str, Any]:
+        return import_workflow(_loader, source_path, workflow_name, is_global, project_path)
+
+    @registry.tool(
+        name="reload_cache",
+        description="Clear the workflow cache. Use this after modifying workflow YAML files.",
+    )
+    def _reload_cache() -> dict[str, Any]:
+        return reload_cache(_loader)
+
+    @registry.tool(
+        name="close_terminal",
+        description=(
+            "Close the current terminal window/pane (agent self-termination). "
+            "Launches ~/.gobby/scripts/agent_shutdown.sh which handles "
+            "terminal-specific shutdown (tmux, iTerm, etc.). Rebuilds script if missing."
+        ),
+    )
+    async def _close_terminal(
+        signal: str = "TERM",
+        delay_ms: int = 0,
+    ) -> dict[str, Any]:
+        return await close_terminal(signal, delay_ms)
+
+    return registry

gobby/mcp_proxy/tools/workflows/_artifacts.py

@@ -0,0 +1,225 @@
+"""
+Artifact and variable tools for workflows.
+"""
+
+import logging
+from datetime import UTC, datetime
+from typing import Any
+
+from gobby.mcp_proxy.tools.workflows._resolution import (
+    resolve_session_id,
+    resolve_session_task_value,
+)
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.workflows.definitions import WorkflowState
+from gobby.workflows.state_manager import WorkflowStateManager
+
+logger = logging.getLogger(__name__)
+
+
+def mark_artifact_complete(
+    state_manager: WorkflowStateManager,
+    session_manager: LocalSessionManager,
+    artifact_type: str,
+    file_path: str,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Register an artifact as complete.
+
+    Args:
+        state_manager: WorkflowStateManager instance
+        session_manager: LocalSessionManager instance
+        artifact_type: Type of artifact (e.g., "plan", "spec", "test")
+        file_path: Path to the artifact file
+        session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
+
+    Returns:
+        Success status
+    """
+    # Require explicit session_id to prevent cross-session bleed
+    if not session_id:
+        return {
+            "success": False,
+            "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
+        }
+
+    # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+    try:
+        resolved_session_id = resolve_session_id(session_manager, session_id)
+    except ValueError as e:
+        return {"success": False, "error": str(e)}
+
+    state = state_manager.get_state(resolved_session_id)
+    if not state:
+        return {"success": False, "error": "No workflow active for session"}
+
+    # Update artifacts
+    state.artifacts[artifact_type] = file_path
+    state_manager.save_state(state)
+
+    return {"success": True}
+
+
+def set_variable(
+    state_manager: WorkflowStateManager,
+    session_manager: LocalSessionManager,
+    db: DatabaseProtocol,
+    name: str,
+    value: str | int | float | bool | None,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Set a workflow variable for the current session.
+
+    Variables set this way are session-scoped - they persist in the database
+    for the duration of the session but do not modify the workflow YAML file.
+
+    This is useful for:
+    - Setting session_epic to enforce epic completion before stopping
+    - Setting is_worktree to mark a session as a worktree agent
+    - Dynamic configuration without modifying workflow definitions
+
+    Args:
+        state_manager: WorkflowStateManager instance
+        session_manager: LocalSessionManager instance
+        db: LocalDatabase instance
+        name: Variable name (e.g., "session_epic", "is_worktree")
+        value: Variable value (string, number, boolean, or null)
+        session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
+
+    Returns:
+        Success status and updated variables
+    """
+    # Require explicit session_id to prevent cross-session bleed
+    if not session_id:
+        return {
+            "success": False,
+            "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
+        }
+
+    # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+    try:
+        resolved_session_id = resolve_session_id(session_manager, session_id)
+    except ValueError as e:
+        return {"success": False, "error": str(e)}
+
+    # Get or create state
+    state = state_manager.get_state(resolved_session_id)
+    if not state:
+        # Create a minimal lifecycle state for variable storage
+        state = WorkflowState(
+            session_id=resolved_session_id,
+            workflow_name="__lifecycle__",
+            step="",
+            step_entered_at=datetime.now(UTC),
+            variables={},
+        )
+
+    # Block modification of session_task when a real workflow is active
+    # This prevents circumventing workflows by changing the tracked task
+    if name == "session_task" and state.workflow_name != "__lifecycle__":
+        current_value = state.variables.get("session_task")
+        if current_value is not None and value != current_value:
+            return {
+                "success": False,
+                "error": (
+                    f"Cannot modify session_task while workflow '{state.workflow_name}' is active. "
+                    f"Current value: {current_value}. "
+                    f"Use end_workflow() first if you need to change the tracked task."
+                ),
+            }
+
+    # Resolve session_task references (#N or N) to UUIDs upfront
+    # This prevents repeated resolution failures in condition evaluation
+    if name == "session_task" and isinstance(value, str):
+        try:
+            value = resolve_session_task_value(value, resolved_session_id, session_manager, db)
+        except (ValueError, KeyError) as e:
+            logger.warning(
+                f"Failed to resolve session_task value '{value}' for session {resolved_session_id}: {e}"
+            )
+            return {
+                "success": False,
+                "error": f"Failed to resolve session_task value '{value}': {e}",
+            }
+
+    # Set the variable
+    state.variables[name] = value
+    state_manager.save_state(state)
+
+    # Add deprecation warning for session_task on __lifecycle__ workflow
+    if name == "session_task" and state.workflow_name == "__lifecycle__":
+        return {
+            "warning": (
+                "DEPRECATED: Setting session_task via set_variable on __lifecycle__ workflow. "
+                "Prefer using activate_workflow(variables={session_task: ...}) instead."
+            )
+        }
+
+    return {}
+
+
+def get_variable(
+    state_manager: WorkflowStateManager,
+    session_manager: LocalSessionManager,
+    name: str | None = None,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Get workflow variable(s) for the current session.
+
+    Args:
+        state_manager: WorkflowStateManager instance
+        session_manager: LocalSessionManager instance
+        name: Variable name to get (if None, returns all variables)
+        session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
+
+    Returns:
+        Variable value(s) and session info
+    """
+    # Require explicit session_id to prevent cross-session bleed
+    if not session_id:
+        return {
+            "success": False,
+            "error": "session_id is required. Pass the session ID explicitly to prevent cross-session variable bleed.",
+        }
+
+    # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+    try:
+        resolved_session_id = resolve_session_id(session_manager, session_id)
+    except ValueError as e:
+        return {"success": False, "error": str(e)}
+
+    state = state_manager.get_state(resolved_session_id)
+    if not state:
+        if name:
+            return {
+                "success": True,
+                "session_id": resolved_session_id,
+                "variable": name,
+                "value": None,
+                "exists": False,
+            }
+        return {
+            "success": True,
+            "session_id": resolved_session_id,
+            "variables": {},
+        }
+
+    if name:
+        value = state.variables.get(name)
+        return {
+            "success": True,
+            "session_id": resolved_session_id,
+            "variable": name,
+            "value": value,
+            "exists": name in state.variables,
+        }
+
+    return {
+        "success": True,
+        "session_id": resolved_session_id,
+        "variables": state.variables,
+    }