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

gobby/mcp_proxy/tools/tasks/_lifecycle.py

@@ -3,6 +3,7 @@
 Provides task lifecycle tools: close, reopen, delete, and label management.
 """
 
+import uuid
 from typing import Any
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
@@ -20,6 +21,15 @@ from gobby.storage.tasks import TaskNotFoundError
 from gobby.storage.worktrees import LocalWorktreeManager
 
 
+def _is_uuid(value: str) -> bool:
+    """Check if a string is a valid UUID (not a ref like #123)."""
+    try:
+        uuid.UUID(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+
+
 def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
     """Create a registry with task lifecycle tools.
 
@@ -121,7 +131,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                             "You must commit your changes and link them to the task before closing."
                         ),
                         "suggestion": (
-                            "Commit your changes with `[#task_id]` in the message, "
+                            f"Commit your changes with `[{ctx.get_current_project_name() or 'project'}-#task_id]` in the message, "
                             "or pass `commit_sha` to `close_task`."
                         ),
                     }
@@ -184,18 +194,20 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         current_commit_sha = run_git_command(["git", "rev-parse", "--short", "HEAD"], cwd=cwd)
 
         if route_to_review:
-            # Route to review status instead of closing
-            # Task stays in review until user explicitly closes
+            # Route to needs_review status instead of closing
+            # Task stays in needs_review until user explicitly closes
             ctx.task_manager.update_task(
                 resolved_id,
-                status="review",
+                status="needs_review",
                 validation_override_reason=override_justification if store_override else None,
             )
 
             # Auto-link session if provided
             if resolved_session_id:
                 try:
-                    ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "review")
+                    ctx.session_task_manager.link_task(
+                        resolved_session_id, resolved_id, "needs_review"
+                    )
                 except Exception:
                     pass  # nosec B110 - best-effort linking
 
@@ -235,7 +247,17 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         if resolved_session_id:
             try:
                 state = ctx.workflow_state_manager.get_state(resolved_session_id)
-                if state and state.variables.get("claimed_task_id") == resolved_id:
+                if state:
+                    # Resolve claimed_task_id to UUID if it's a ref (backward compat)
+                    claimed_task_id = state.variables.get("claimed_task_id")
+                    if claimed_task_id and not _is_uuid(claimed_task_id):
+                        try:
+                            claimed_task = ctx.task_manager.get_task(claimed_task_id)
+                            if claimed_task:
+                                claimed_task_id = claimed_task.id
+                        except Exception:  # nosec B110 - keep original ID if resolution fails
+                            claimed_task_id = claimed_task_id  # explicit no-op
+                if state and claimed_task_id == resolved_id:
                     # Check if clear_task_on_close is enabled (default: True)
                     clear_on_close = state.variables.get("clear_task_on_close", True)
                     if clear_on_close:
@@ -267,7 +289,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
     registry.register(
         name="close_task",
-        description="Close a task. Pass commit_sha to link and close in one call: close_task(task_id, commit_sha='abc123'). Or include [#N] in commit message for auto-linking. Parent tasks require all children closed. Validation auto-skipped for: duplicate, already_implemented, wont_fix, obsolete.",
+        description="Close a task. Pass commit_sha to link and close in one call: close_task(task_id, commit_sha='abc123'). Or include [project-#N] in commit message for auto-linking. Parent tasks require all children closed. Validation auto-skipped for: duplicate, already_implemented, wont_fix, obsolete, out_of_repo.",
         input_schema={
             "type": "object",
             "properties": {
@@ -277,7 +299,7 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 },
                 "reason": {
                     "type": "string",
-                    "description": 'Reason for closing. Use "duplicate", "already_implemented", "wont_fix", or "obsolete" to auto-skip validation and commit check.',
+                    "description": 'Reason for closing. Use "duplicate", "already_implemented", "wont_fix", "obsolete", or "out_of_repo" to auto-skip validation and commit check.',
                     "default": "completed",
                 },
                 "changes_summary": {
@@ -567,6 +589,17 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         except Exception:
             pass  # nosec B110 - best-effort linking
 
+        # Set task_claimed workflow variable (enables Edit/Write hooks)
+        # This mirrors create_task behavior in _crud.py
+        try:
+            state = ctx.workflow_state_manager.get_state(resolved_session_id)
+            if state:
+                state.variables["task_claimed"] = True
+                state.variables["claimed_task_id"] = resolved_id  # Always use UUID
+                ctx.workflow_state_manager.save_state(state)
+        except Exception:
+            pass  # nosec B110 - best-effort variable setting
+
         return {}
 
     registry.register(
@@ -594,4 +627,88 @@ def create_lifecycle_registry(ctx: RegistryContext) -> InternalToolRegistry:
         func=claim_task,
     )
 
+    def mark_task_for_review(
+        task_id: str,
+        session_id: str,
+        review_notes: str | None = None,
+    ) -> dict[str, Any]:
+        """Mark a task as ready for review.
+
+        Sets status to 'needs_review'. Use this when work is complete
+        but needs human verification before closing.
+
+        Args:
+            task_id: Task reference (#N, path, or UUID)
+            session_id: Session ID marking the task for review
+            review_notes: Optional notes for the reviewer
+
+        Returns:
+            Empty dict on success, or error dict with details.
+        """
+        # Resolve task reference (supports #N, path, UUID formats)
+        try:
+            resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id)
+        except TaskNotFoundError as e:
+            return {"success": False, "error": str(e)}
+        except ValueError as e:
+            return {"success": False, "error": str(e)}
+
+        task = ctx.task_manager.get_task(resolved_id)
+        if not task:
+            return {"success": False, "error": f"Task {task_id} not found"}
+
+        # Resolve session_id to UUID (accepts #N, N, UUID, or prefix)
+        resolved_session_id = session_id
+        try:
+            resolved_session_id = ctx.resolve_session_id(session_id)
+        except ValueError:
+            pass  # Fall back to raw value if resolution fails
+
+        # Build update kwargs
+        update_kwargs: dict[str, Any] = {"status": "needs_review"}
+
+        # Append review notes to description if provided
+        if review_notes:
+            current_desc = task.description or ""
+            review_section = f"\n\n[Review Notes]\n{review_notes}"
+            update_kwargs["description"] = current_desc + review_section
+
+        # Update task status to needs_review
+        updated = ctx.task_manager.update_task(resolved_id, **update_kwargs)
+        if not updated:
+            return {"success": False, "error": f"Failed to mark task {task_id} for review"}
+
+        # Link task to session (best-effort, don't fail if this fails)
+        try:
+            ctx.session_task_manager.link_task(resolved_session_id, resolved_id, "needs_review")
+        except Exception:
+            pass  # nosec B110 - best-effort linking
+
+        return {}
+
+    registry.register(
+        name="mark_task_for_review",
+        description="Mark a task as ready for review. Sets status to 'needs_review'. Use this when work is complete but needs human verification before closing.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "Task reference: #N (e.g., #1, #47), path (e.g., 1.2.3), or UUID",
+                },
+                "session_id": {
+                    "type": "string",
+                    "description": "Your session ID (accepts #N, N, UUID, or prefix). The session marking the task for review.",
+                },
+                "review_notes": {
+                    "type": "string",
+                    "description": "Optional notes for the reviewer explaining what was done and what to verify.",
+                    "default": None,
+                },
+            },
+            "required": ["task_id", "session_id"],
+        },
+        func=mark_task_for_review,
+    )
+
     return registry

gobby/mcp_proxy/tools/tasks/_lifecycle_validation.py

@@ -61,7 +61,8 @@ def validate_commit_requirements(
                 '- Task was already done: reason="already_implemented"\n'
                 '- Task is no longer needed: reason="obsolete"\n'
                 '- Task duplicates another: reason="duplicate"\n'
-                '- Decided not to do it: reason="wont_fix"'
+                '- Decided not to do it: reason="wont_fix"\n'
+                '- Changes outside repo (e.g., ~/.gobby/config.yaml): reason="out_of_repo"'
             ),
         )
 

gobby/mcp_proxy/tools/tasks/_search.py

@@ -43,7 +43,7 @@ def create_search_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         Args:
             query: Search query text (required). Natural language query.
-            status: Filter by status (open, in_progress, review, closed).
+            status: Filter by status (open, in_progress, needs_review, closed).
                 Can be a single status or comma-separated list.
             task_type: Filter by task type (task, bug, feature, epic)
             priority: Filter by priority (1=High, 2=Medium, 3=Low)

gobby/mcp_proxy/tools/workflows/__init__.py

@@ -0,0 +1,273 @@
+"""
+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. "
+            "Pass session_id to reliably target the correct terminal PID."
+        ),
+    )
+    async def _close_terminal(
+        session_id: str | None = None,
+        signal: str = "TERM",
+        delay_ms: int = 0,
+    ) -> dict[str, Any]:
+        return await close_terminal(
+            session_id=session_id,
+            session_manager=_session_manager,
+            signal=signal,
+            delay_ms=delay_ms,
+        )
+
+    return registry