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

gobby/mcp_proxy/tools/workflows/_query.py

@@ -0,0 +1,226 @@
+"""
+Query tools for workflows.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from gobby.mcp_proxy.tools.workflows._resolution import resolve_session_id
+from gobby.storage.sessions import LocalSessionManager
+from gobby.utils.project_context import get_workflow_project_path
+from gobby.workflows.definitions import WorkflowDefinition
+from gobby.workflows.loader import WorkflowLoader
+from gobby.workflows.state_manager import WorkflowStateManager
+
+logger = logging.getLogger(__name__)
+
+
+def get_workflow(
+    loader: WorkflowLoader,
+    name: str,
+    project_path: str | None = None,
+) -> dict[str, Any]:
+    """
+    Get workflow details including steps, triggers, and settings.
+
+    Args:
+        loader: WorkflowLoader instance
+        name: Workflow name (without .yaml extension)
+        project_path: Project directory path. Auto-discovered from cwd if not provided.
+
+    Returns:
+        Workflow definition details
+    """
+    # Auto-discover project path if not provided
+    if not project_path:
+        discovered = get_workflow_project_path()
+        if discovered:
+            project_path = str(discovered)
+
+    proj = Path(project_path) if project_path else None
+    definition = loader.load_workflow(name, proj)
+
+    if not definition:
+        return {"success": False, "error": f"Workflow '{name}' not found"}
+
+    # Handle WorkflowDefinition vs PipelineDefinition
+    if isinstance(definition, WorkflowDefinition):
+        return {
+            "success": True,
+            "name": definition.name,
+            "type": definition.type,
+            "description": definition.description,
+            "version": definition.version,
+            "steps": (
+                [
+                    {
+                        "name": s.name,
+                        "description": s.description,
+                        "allowed_tools": s.allowed_tools,
+                        "blocked_tools": s.blocked_tools,
+                    }
+                    for s in definition.steps
+                ]
+                if definition.steps
+                else []
+            ),
+            "triggers": (
+                {name: len(actions) for name, actions in definition.triggers.items()}
+                if definition.triggers
+                else {}
+            ),
+            "settings": definition.settings,
+        }
+    else:
+        # PipelineDefinition
+        return {
+            "success": True,
+            "name": definition.name,
+            "type": definition.type,
+            "description": definition.description,
+            "version": definition.version,
+            "steps": (
+                [{"id": s.id, "exec": s.exec, "prompt": s.prompt} for s in definition.steps]
+                if definition.steps
+                else []
+            ),
+            "triggers": {},
+            "settings": {},
+        }
+
+
+def list_workflows(
+    loader: WorkflowLoader,
+    project_path: str | None = None,
+    workflow_type: str | None = None,
+    global_only: bool = False,
+) -> dict[str, Any]:
+    """
+    List available workflows.
+
+    Lists workflows from both project (.gobby/workflows) and global (~/.gobby/workflows)
+    directories. Project workflows shadow global ones with the same name.
+
+    Args:
+        loader: WorkflowLoader instance
+        project_path: Project directory path. Auto-discovered from cwd if not provided.
+        workflow_type: Filter by type ("step" or "lifecycle")
+        global_only: If True, only show global workflows (ignore project)
+
+    Returns:
+        List of workflows with name, type, description, and source
+    """
+
+    # Auto-discover project path if not provided
+    if not project_path:
+        discovered = get_workflow_project_path()
+        if discovered:
+            project_path = str(discovered)
+
+    search_dirs = list(loader.global_dirs)
+    proj = Path(project_path) if project_path else None
+
+    # Include project workflows unless global_only (project searched first to shadow global)
+    if not global_only and proj:
+        project_dir = proj / ".gobby" / "workflows"
+        if project_dir.exists():
+            search_dirs.insert(0, project_dir)
+
+    workflows = []
+    seen_names = set()
+
+    for search_dir in search_dirs:
+        if not search_dir.exists():
+            continue
+
+        is_project = proj and search_dir == (proj / ".gobby" / "workflows")
+
+        for yaml_path in search_dir.glob("*.yaml"):
+            name = yaml_path.stem
+            if name in seen_names:
+                continue
+
+            try:
+                with open(yaml_path, encoding="utf-8") as f:
+                    data = yaml.safe_load(f)
+
+                if not data:
+                    continue
+
+                wf_type = data.get("type", "step")
+
+                if workflow_type and wf_type != workflow_type:
+                    continue
+
+                workflows.append(
+                    {
+                        "name": name,
+                        "type": wf_type,
+                        "description": data.get("description", ""),
+                        "source": "project" if is_project else "global",
+                    }
+                )
+                seen_names.add(name)
+
+            except Exception as e:
+                logger.debug(
+                    "Skipping invalid workflow file %s: %s",
+                    yaml_path,
+                    e,
+                    exc_info=True,
+                )  # nosec B110
+
+    return {"workflows": workflows, "count": len(workflows)}
+
+
+def get_workflow_status(
+    state_manager: WorkflowStateManager,
+    session_manager: LocalSessionManager,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """
+    Get current workflow step and state.
+
+    Args:
+        state_manager: WorkflowStateManager instance
+        session_manager: LocalSessionManager instance
+        session_id: Session reference (accepts #N, N, UUID, or prefix) - required to prevent cross-session bleed
+
+    Returns:
+        Workflow state including step, action counts, artifacts
+    """
+    # Require explicit session_id to prevent cross-session bleed
+    if not session_id:
+        return {
+            "has_workflow": 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 {"has_workflow": False, "error": str(e)}
+
+    state = state_manager.get_state(resolved_session_id)
+    if not state:
+        return {"has_workflow": False, "session_id": resolved_session_id}
+
+    return {
+        "has_workflow": True,
+        "session_id": resolved_session_id,
+        "workflow_name": state.workflow_name,
+        "step": state.step,
+        "step_action_count": state.step_action_count,
+        "total_action_count": state.total_action_count,
+        "reflection_pending": state.reflection_pending,
+        "artifacts": list(state.artifacts.keys()) if state.artifacts else [],
+        "variables": state.variables,
+        "task_progress": (
+            f"{state.current_task_index + 1}/{len(state.task_list)}" if state.task_list else None
+        ),
+        "updated_at": state.updated_at.isoformat() if state.updated_at else None,
+    }

gobby/mcp_proxy/tools/workflows/_resolution.py

@@ -0,0 +1,78 @@
+"""
+Resolution utilities for workflow tools.
+
+Provides functions to resolve session and task references from various
+formats (#N, N, UUID, prefix) to canonical UUIDs.
+"""
+
+import logging
+from typing import Any
+
+from gobby.storage.database import DatabaseProtocol
+from gobby.storage.sessions import LocalSessionManager
+from gobby.storage.tasks._id import resolve_task_reference
+from gobby.storage.tasks._models import TaskNotFoundError
+from gobby.utils.project_context import get_project_context
+
+logger = logging.getLogger(__name__)
+
+
+def resolve_session_id(session_manager: LocalSessionManager, ref: str) -> str:
+    """Resolve session reference (#N, N, UUID, or prefix) to UUID."""
+    project_ctx = get_project_context()
+    project_id = project_ctx.get("id") if project_ctx else None
+    return session_manager.resolve_session_reference(ref, project_id)
+
+
+def resolve_session_task_value(
+    value: Any,
+    session_id: str | None,
+    session_manager: LocalSessionManager,
+    db: DatabaseProtocol,
+) -> Any:
+    """
+    Resolve a session_task value from seq_num reference (#N or N) to UUID.
+
+    This prevents repeated resolution failures in condition evaluation when
+    task_tree_complete() is called with a seq_num that requires project_id.
+
+    Args:
+        value: The value to potentially resolve (e.g., "#4424", "47", or a UUID)
+        session_id: Session ID to look up project_id
+        session_manager: Session manager for lookups
+        db: Database for task resolution
+
+    Returns:
+        Resolved UUID if value was a seq_num reference, otherwise original value
+    """
+    # Only process string values that look like seq_num references
+    if not isinstance(value, str):
+        return value
+
+    # Check if it's a seq_num reference (#N or plain N)
+    is_seq_ref = value.startswith("#") or value.isdigit()
+    if not is_seq_ref:
+        return value
+
+    # Need session to get project_id
+    if not session_id:
+        logger.warning(f"Cannot resolve task reference '{value}': no session_id provided")
+        return value
+
+    # Get project_id from session
+    session = session_manager.get(session_id)
+    if not session or not session.project_id:
+        logger.warning(f"Cannot resolve task reference '{value}': session has no project_id")
+        return value
+
+    # Resolve the reference
+    try:
+        resolved = resolve_task_reference(db, value, session.project_id)
+        logger.debug(f"Resolved session_task '{value}' to UUID '{resolved}'")
+        return resolved
+    except TaskNotFoundError as e:
+        logger.warning(f"Could not resolve task reference '{value}': {e}")
+        return value
+    except Exception as e:
+        logger.warning(f"Unexpected error resolving task reference '{value}': {e}")
+        return value

gobby/mcp_proxy/tools/workflows/_terminal.py

@@ -0,0 +1,175 @@
+"""
+Terminal tools for workflows.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import stat
+import subprocess  # nosec B404
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from gobby.paths import get_install_dir
+
+if TYPE_CHECKING:
+    from gobby.storage.sessions import LocalSessionManager
+
+logger = logging.getLogger(__name__)
+
+
+async def close_terminal(
+    session_id: str | None = None,
+    session_manager: LocalSessionManager | None = None,
+    signal: str = "TERM",
+    delay_ms: int = 0,
+) -> dict[str, Any]:
+    """
+    Close the current terminal by running the agent shutdown script.
+
+    This is for agent self-termination (meeseeks-style). The agent calls
+    this to close its own terminal window when done with its workflow.
+
+    The script is located at ~/.gobby/scripts/agent_shutdown.sh and is
+    automatically rebuilt if missing. It handles different terminal types
+    (tmux, iTerm, Terminal.app, Ghostty, Kitty, WezTerm, etc.).
+
+    Args:
+        session_id: Session ID to look up terminal PID from. Accepts #N, N,
+            UUID, or prefix. If provided with session_manager, the terminal
+            PID is resolved from session.terminal_context.parent_pid.
+        session_manager: LocalSessionManager for session lookups.
+        signal: Signal to use for shutdown (TERM, KILL, INT). Default: TERM.
+        delay_ms: Optional delay in milliseconds before shutdown. Default: 0.
+
+    Returns:
+        Dict with success status and message.
+    """
+    # Script location
+    gobby_dir = Path.home() / ".gobby"
+    scripts_dir = gobby_dir / "scripts"
+    script_path = scripts_dir / "agent_shutdown.sh"
+
+    # Source script from the install directory (single source of truth)
+    source_script_path = get_install_dir() / "shared" / "scripts" / "agent_shutdown.sh"
+
+    def get_script_version(script_content: str) -> str | None:
+        """Extract VERSION marker from script content."""
+        import re
+
+        match = re.search(r"^# VERSION:\s*(.+)$", script_content, re.MULTILINE)
+        return match.group(1).strip() if match else None
+
+    # Ensure directories exist and script is present/up-to-date
+    script_rebuilt = False
+    try:
+        scripts_dir.mkdir(parents=True, exist_ok=True)
+
+        # Read source script content
+        if source_script_path.exists():
+            source_content = source_script_path.read_text()
+            source_version = get_script_version(source_content)
+        else:
+            logger.warning(f"Source shutdown script not found at {source_script_path}")
+            source_content = None
+            source_version = None
+
+        # Check if installed script exists and compare versions
+        needs_rebuild = False
+        if not script_path.exists():
+            needs_rebuild = True
+        elif source_content:
+            installed_content = script_path.read_text()
+            installed_version = get_script_version(installed_content)
+            # Rebuild if versions differ or installed has no version marker
+            if installed_version != source_version:
+                needs_rebuild = True
+                logger.info(
+                    f"Shutdown script version mismatch: installed={installed_version}, source={source_version}"
+                )
+
+        if needs_rebuild:
+            if not source_content:
+                logger.error(
+                    f"Cannot rebuild shutdown script at {script_path}: "
+                    f"source script not found at {source_script_path}"
+                )
+                return {
+                    "success": False,
+                    "error": f"Source shutdown script not found at {source_script_path}",
+                }
+            script_path.write_text(source_content)
+            # Make executable
+            script_path.chmod(script_path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP)
+            script_rebuilt = True
+            logger.info(f"Created/updated agent shutdown script at {script_path}")
+    except OSError as e:
+        return {
+            "success": False,
+            "error": f"Failed to create shutdown script: {e}",
+        }
+
+    # Validate signal
+    valid_signals = {"TERM", "KILL", "INT", "HUP", "QUIT"}
+    if signal.upper() not in valid_signals:
+        return {
+            "success": False,
+            "error": f"Invalid signal '{signal}'. Valid: {valid_signals}",
+        }
+
+    # Apply delay before launching script (non-blocking)
+    if delay_ms > 0:
+        await asyncio.sleep(delay_ms / 1000.0)
+
+    # Resolve terminal PID from session context if available
+    target_pid: int | None = None
+    if session_id and session_manager:
+        from gobby.mcp_proxy.tools.workflows._resolution import resolve_session_id
+
+        try:
+            resolved_id = resolve_session_id(session_manager, session_id)
+            if resolved_id:
+                session = session_manager.get(resolved_id)
+                if session and session.terminal_context:
+                    pid_value = session.terminal_context.get("parent_pid")
+                    if pid_value is not None:
+                        target_pid = int(pid_value)
+                        logger.info(f"Resolved terminal PID {target_pid} from session {session_id}")
+        except Exception as e:
+            logger.warning(f"Failed to resolve terminal PID from session: {e}")
+
+    # Launch the script
+    try:
+        # Run in background - we don't wait for it since it kills our process
+        env = os.environ.copy()
+
+        # Pass PID as first arg if available, otherwise script will discover via PPID
+        pid_arg = str(target_pid) if target_pid else ""
+        subprocess.Popen(  # nosec B603 - script path is from gobby scripts directory
+            [str(script_path), pid_arg, signal.upper(), "0"],  # Delay already applied
+            env=env,
+            start_new_session=True,  # Detach from parent
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+        result: dict[str, Any] = {
+            "success": True,
+            "message": "Shutdown script launched",
+            "script_path": str(script_path),
+            "script_rebuilt": script_rebuilt,
+            "signal": signal.upper(),
+        }
+        if target_pid:
+            result["target_pid"] = target_pid
+            result["pid_source"] = "session_terminal_context"
+        else:
+            result["pid_source"] = "ppid_discovery"
+        return result
+    except OSError as e:
+        return {
+            "success": False,
+            "error": f"Failed to launch shutdown script: {e}",
+        }

gobby/mcp_proxy/tools/worktrees.py

@@ -169,14 +169,15 @@ def _copy_project_json_to_worktree(
 
 
 def _install_provider_hooks(
-    provider: Literal["claude", "gemini", "codex", "antigravity"] | None,
+    provider: Literal["claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"]
+    | None,
     worktree_path: str | Path,
 ) -> bool:
     """
     Install CLI hooks for the specified provider in the worktree.
 
     Args:
-        provider: Provider name ('claude', 'gemini', 'antigravity', or None)
+        provider: Provider name ('claude', 'gemini', 'antigravity', 'cursor', 'windsurf', 'copilot', or None)
         worktree_path: Path to worktree directory
 
     Returns:
@@ -196,6 +197,16 @@ def _install_provider_hooks(
                 return True
             else:
                 logger.warning(f"Failed to install Claude hooks: {result.get('error')}")
+        elif provider in ("cursor", "windsurf", "copilot"):
+            # These editors use Claude hooks format
+            from gobby.cli.installers.claude import install_claude
+
+            result = install_claude(worktree_path_obj)
+            if result["success"]:
+                logger.info(f"Installed {provider} hooks in worktree: {worktree_path}")
+                return True
+            else:
+                logger.warning(f"Failed to install {provider} hooks: {result.get('error')}")
         elif provider == "gemini":
             from gobby.cli.installers.gemini import install_gemini
 
@@ -326,7 +337,10 @@ def create_worktrees_registry(
         worktree_path: str | None = None,
         create_branch: bool = True,
         project_path: str | None = None,
-        provider: Literal["claude", "gemini", "codex", "antigravity"] | None = None,
+        provider: Literal[
+            "claude", "gemini", "codex", "antigravity", "cursor", "windsurf", "copilot"
+        ]
+        | None = None,
     ) -> dict[str, Any]:
         """
         Create a new git worktree.
@@ -338,7 +352,7 @@ def create_worktrees_registry(
             worktree_path: Optional custom path (defaults to ../{branch_name}).
             create_branch: Whether to create a new branch (default: True).
             project_path: Path to project directory (pass cwd from CLI).
-            provider: CLI provider to install hooks for (claude, gemini, codex, antigravity).
+            provider: CLI provider to install hooks for (claude, gemini, codex, antigravity, cursor, windsurf, copilot).
                      If specified, installs hooks so agents can communicate with daemon.
 
         Returns:
@@ -451,7 +465,7 @@ def create_worktrees_registry(
     async def list_worktrees(
         status: str | None = None,
         agent_session_id: str | None = None,
-        limit: int = 50,
+        limit: int | str = 50,
     ) -> dict[str, Any]:
         """
         List worktrees with optional filters.
@@ -464,6 +478,9 @@ def create_worktrees_registry(
         Returns:
             Dict with list of worktrees.
         """
+        # Handle string inputs from MCP
+        limit = int(limit) if isinstance(limit, str) else limit
+
         # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
         resolved_session_id = agent_session_id
         if agent_session_id:
@@ -569,7 +586,7 @@ def create_worktrees_registry(
     )
     async def delete_worktree(
         worktree_id: str,
-        force: bool = False,
+        force: bool | str = False,
         project_path: str | None = None,
     ) -> dict[str, Any]:
         """
@@ -591,6 +608,9 @@ def create_worktrees_registry(
         Returns:
             Dict with success status.
         """
+        # Handle string inputs from MCP
+        force = force in (True, "true", "True", "1") if isinstance(force, str) else force
+
         worktree = worktree_storage.get(worktree_id)
 
         if not worktree:
@@ -611,8 +631,11 @@ def create_worktrees_registry(
                 # nosec B110 - if context resolution fails, continue without git manager
                 pass
 
-        # Check for uncommitted changes if not forcing
-        if resolved_git_mgr and Path(worktree.worktree_path).exists():
+        # Check if worktree path exists
+        worktree_exists = Path(worktree.worktree_path).exists()
+
+        # Check for uncommitted changes if not forcing (only if path exists)
+        if resolved_git_mgr and worktree_exists:
             status = resolved_git_mgr.get_worktree_status(worktree.worktree_path)
             if status and status.has_uncommitted_changes and not force:
                 return {
@@ -621,8 +644,8 @@ def create_worktrees_registry(
                     "uncommitted_changes": True,
                 }
 
-        # Delete git worktree
-        if resolved_git_mgr:
+        # Delete git worktree (only if path exists - handles orphaned DB records)
+        if resolved_git_mgr and worktree_exists:
             result = resolved_git_mgr.delete_worktree(
                 worktree.worktree_path,
                 force=force,
@@ -634,6 +657,11 @@ def create_worktrees_registry(
                     "success": False,
                     "error": result.error or "Failed to delete git worktree",
                 }
+        elif not worktree_exists:
+            # Worktree path gone (manually deleted) - just clean up DB record
+            logger.info(
+                f"Worktree path {worktree.worktree_path} doesn't exist, cleaning up DB record only"
+            )
 
         # Delete database record
         deleted = worktree_storage.delete(worktree_id)
@@ -744,8 +772,8 @@ def create_worktrees_registry(
     )
     async def detect_stale_worktrees(
         project_path: str | None = None,
-        hours: int = 24,
-        limit: int = 50,
+        hours: int | str = 24,
+        limit: int | str = 50,
     ) -> dict[str, Any]:
         """
         Find stale worktrees (no activity for N hours).
@@ -758,6 +786,10 @@ def create_worktrees_registry(
         Returns:
             Dict with list of stale worktrees.
         """
+        # Handle string inputs from MCP (JSON params come as strings)
+        hours = int(hours) if isinstance(hours, str) else hours
+        limit = int(limit) if isinstance(limit, str) else limit
+
         _, resolved_project_id, error = _resolve_project_context(
             project_path, git_manager, project_id
         )
@@ -794,9 +826,9 @@ def create_worktrees_registry(
     )
     async def cleanup_stale_worktrees(
         project_path: str | None = None,
-        hours: int = 24,
-        dry_run: bool = True,
-        delete_git: bool = False,
+        hours: int | str = 24,
+        dry_run: bool | str = True,
+        delete_git: bool | str = False,
     ) -> dict[str, Any]:
         """
         Cleanup stale worktrees.
@@ -810,6 +842,13 @@ def create_worktrees_registry(
         Returns:
             Dict with cleanup results.
         """
+        # Handle string inputs from MCP (JSON params come as strings)
+        hours = int(hours) if isinstance(hours, str) else hours
+        dry_run = dry_run in (True, "true", "True", "1") if isinstance(dry_run, str) else dry_run
+        delete_git = (
+            delete_git in (True, "true", "True", "1") if isinstance(delete_git, str) else delete_git
+        )
+
         resolved_git_manager, resolved_project_id, error = _resolve_project_context(
             project_path, git_manager, project_id
         )