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

gobby/mcp_proxy/tools/tasks/_crud.py

@@ -3,16 +3,20 @@
 Provides core task operations: create, get, update, list, and tree building.
 """
 
+import logging
 from typing import Any
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 from gobby.mcp_proxy.tools.tasks._context import RegistryContext
 from gobby.mcp_proxy.tools.tasks._helpers import _infer_category
 from gobby.mcp_proxy.tools.tasks._resolution import resolve_task_id_for_mcp
+from gobby.storage.task_dependencies import DependencyCycleError
 from gobby.storage.tasks import TaskNotFoundError
 from gobby.utils.project_context import get_project_context
 from gobby.utils.project_init import initialize_project
 
+logger = logging.getLogger(__name__)
+
 
 def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
     """Create a registry with task CRUD tools.
@@ -36,9 +40,11 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
         task_type: str = "task",
         parent_task_id: str | None = None,
         blocks: list[str] | None = None,
+        depends_on: list[str] | None = None,
         labels: list[str] | None = None,
         category: str | None = None,
         validation_criteria: str | None = None,
+        claim: bool = False,
     ) -> dict[str, Any]:
         """Create a single task in the current project.
 
@@ -47,15 +53,17 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         Args:
             title: Task title
-            session_id: Your session ID for tracking (REQUIRED)
+            session_id: Your session ID for tracking (REQUIRED).
             description: Detailed description
             priority: Priority level (1=High, 2=Medium, 3=Low)
             task_type: Task type (task, bug, feature, epic)
             parent_task_id: Optional parent task ID
             blocks: List of task IDs that this new task blocks
+            depends_on: List of task IDs that this new task depends on (must complete first)
             labels: List of labels
             category: Task domain category (test, code, document, research, config, manual)
             validation_criteria: Acceptance criteria for validating completion.
+            claim: If True, auto-claim the task (set assignee and status to in_progress).
 
         Returns:
             Created task dict with id (minimal) or full task details based on config.
@@ -98,10 +106,72 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
 
         task = ctx.task_manager.get_task(create_result["task"]["id"])
 
+        # Link task to session (best-effort) - tracks which session created the task
+        try:
+            ctx.session_task_manager.link_task(session_id, task.id, "created")
+        except Exception:
+            pass  # nosec B110 - best-effort linking
+
+        # Auto-claim if requested: set assignee and status to in_progress
+        if claim:
+            updated_task = ctx.task_manager.update_task(
+                task.id,
+                assignee=session_id,
+                status="in_progress",
+            )
+            if updated_task is None:
+                logger.warning(f"Failed to auto-claim task {task.id}: update_task returned None")
+            else:
+                task = updated_task
+                # Link task to session with "claimed" action (best-effort)
+                try:
+                    ctx.session_task_manager.link_task(session_id, task.id, "claimed")
+                except Exception:
+                    pass  # nosec B110 - best-effort linking
+
+            # Set workflow state for Claude Code (CC doesn't include tool results in PostToolUse)
+            # This mirrors close_task behavior in _lifecycle.py:196-207
+            try:
+                state = ctx.workflow_state_manager.get_state(session_id)
+                if state:
+                    state.variables["task_claimed"] = True
+                    state.variables["claimed_task_id"] = task.id  # Always use UUID
+                    ctx.workflow_state_manager.save_state(state)
+            except Exception:
+                pass  # nosec B110 - best-effort state update
+
         # Handle 'blocks' argument if provided (syntactic sugar)
+        # Collect errors consistently with depends_on handling below
+        dependency_errors: list[str] = []
         if blocks:
             for blocked_id in blocks:
-                ctx.dep_manager.add_dependency(task.id, blocked_id, "blocks")
+                try:
+                    resolved_blocked = resolve_task_id_for_mcp(
+                        ctx.task_manager, blocked_id, project_id
+                    )
+                    ctx.dep_manager.add_dependency(task.id, resolved_blocked, "blocks")
+                except TaskNotFoundError:
+                    dependency_errors.append(f"Task '{blocked_id}' not found (blocks)")
+                except ValueError as e:
+                    dependency_errors.append(f"Invalid ref '{blocked_id}' (blocks): {e}")
+                except DependencyCycleError:
+                    dependency_errors.append(f"Cycle detected for '{blocked_id}' (blocks)")
+
+        # Handle 'depends_on' argument if provided
+        # The new task depends on resolved_blocker, meaning resolved_blocker blocks the new task
+        if depends_on:
+            for blocker_ref in depends_on:
+                try:
+                    resolved_blocker = resolve_task_id_for_mcp(
+                        ctx.task_manager, blocker_ref, project_id
+                    )
+                    ctx.dep_manager.add_dependency(resolved_blocker, task.id, "blocks")
+                except TaskNotFoundError:
+                    dependency_errors.append(f"Task '{blocker_ref}' not found")
+                except ValueError as e:
+                    dependency_errors.append(f"Invalid ref '{blocker_ref}': {e}")
+                except DependencyCycleError:
+                    dependency_errors.append(f"Cycle detected for '{blocker_ref}'")
 
         # Return minimal or full result based on config
         if ctx.show_result_on_create:
@@ -113,6 +183,11 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 "ref": f"#{task.seq_num}",
             }
 
+        # Include dependency errors if any
+        if dependency_errors:
+            result["dependency_errors"] = dependency_errors
+            result["warning"] = f"Task created but {len(dependency_errors)} dependency(s) failed"
+
         return result
 
     registry.register(
@@ -148,6 +223,12 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                     "description": "List of task IDs that this new task blocks (optional)",
                     "default": None,
                 },
+                "depends_on": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "Tasks this new task depends on (must complete first): #N, N, path, or UUID",
+                    "default": None,
+                },
                 "labels": {
                     "type": "array",
                     "items": {"type": "string"},
@@ -169,6 +250,11 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                     "type": "string",
                     "description": "Your session ID (from system context). Required to track which session created the task.",
                 },
+                "claim": {
+                    "type": "boolean",
+                    "description": "If true, auto-claim the task (set assignee to session_id and status to in_progress). Default: false - task is created with status 'open' and no assignee.",
+                    "default": False,
+                },
             },
             "required": ["title", "session_id"],
         },
@@ -265,8 +351,9 @@ def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
                 try:
                     resolved_parent = resolve_task_id_for_mcp(ctx.task_manager, parent_task_id)
                     kwargs["parent_task_id"] = resolved_parent
-                except (TaskNotFoundError, ValueError):
-                    kwargs["parent_task_id"] = parent_task_id  # Fall back to original
+                except (TaskNotFoundError, ValueError) as e:
+                    logger.warning(f"Invalid parent_task_id '{parent_task_id}': {e}")
+                    return {"error": f"Invalid parent_task_id '{parent_task_id}': {e}"}
             else:
                 kwargs["parent_task_id"] = None
         if category is not None:

gobby/mcp_proxy/tools/tasks/_expansion.py

@@ -0,0 +1,348 @@
+"""Expansion tools for skill-based task decomposition.
+
+Provides tools for the /gobby-expand skill workflow:
+1. save_expansion_spec - Save expansion spec to task for later execution
+2. execute_expansion - Create subtasks atomically from saved spec
+3. get_expansion_spec - Check for pending expansion (for resume)
+"""
+
+import json
+import logging
+from typing import Any
+
+from gobby.mcp_proxy.tools.internal import InternalToolRegistry
+from gobby.mcp_proxy.tools.tasks._context import RegistryContext
+from gobby.mcp_proxy.tools.tasks._resolution import resolve_task_id_for_mcp
+from gobby.storage.tasks import TaskNotFoundError
+from gobby.utils.project_context import get_project_context
+
+logger = logging.getLogger(__name__)
+
+
+def create_expansion_registry(ctx: RegistryContext) -> InternalToolRegistry:
+    """Create a registry with task expansion tools.
+
+    Args:
+        ctx: Shared registry context
+
+    Returns:
+        InternalToolRegistry with expansion tools registered
+    """
+    registry = InternalToolRegistry(
+        name="gobby-tasks-expansion",
+        description="Task expansion for skill-based decomposition",
+    )
+
+    async def save_expansion_spec(
+        task_id: str,
+        spec: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Save expansion spec to task.expansion_context for later execution.
+
+        Used by the /gobby-expand skill to persist the expansion plan before
+        creating subtasks. This ensures the spec survives session compaction.
+
+        Args:
+            task_id: Task ID to expand (can be #N, path, or UUID)
+            spec: Expansion specification containing:
+                - subtasks: List of subtask definitions, each with:
+                    - title: Subtask title (required)
+                    - category: code, config, docs, research, planning, manual
+                    - depends_on: List of indices of subtasks this depends on
+                    - validation: Validation criteria string
+                    - description: Optional description
+                    - priority: Optional priority (default: 2)
+
+        Returns:
+            {"saved": True, "task_id": str, "subtask_count": int}
+        """
+        # Get project context
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+
+        # Resolve task ID
+        try:
+            resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id, project_id)
+        except (TaskNotFoundError, ValueError) as e:
+            return {"error": f"Task not found: {e}"}
+
+        # Validate spec structure
+        if "subtasks" not in spec or not isinstance(spec["subtasks"], list):
+            return {"error": "Spec must contain 'subtasks' array"}
+
+        if len(spec["subtasks"]) == 0:
+            return {"error": "Spec must contain at least one subtask"}
+
+        # Validate subtask structure
+        for i, subtask in enumerate(spec["subtasks"]):
+            if "title" not in subtask:
+                return {"error": f"Subtask {i} missing required 'title' field"}
+
+        # Save spec to task
+        ctx.task_manager.update_task(
+            resolved_id,
+            expansion_context=json.dumps(spec),
+            expansion_status="pending",
+        )
+
+        logger.info(
+            f"Saved expansion spec for task {task_id} with {len(spec['subtasks'])} subtasks"
+        )
+
+        return {
+            "saved": True,
+            "task_id": resolved_id,
+            "subtask_count": len(spec["subtasks"]),
+        }
+
+    async def execute_expansion(
+        parent_task_id: str,
+        session_id: str,
+    ) -> dict[str, Any]:
+        """Execute a saved expansion spec atomically.
+
+        Creates all subtasks from the saved spec and wires dependencies.
+        Call save_expansion_spec first to persist the spec.
+
+        Args:
+            parent_task_id: Task ID with saved expansion spec
+            session_id: Session ID for tracking created tasks
+
+        Returns:
+            {"created": ["#N", ...], "count": int} or {"error": str}
+        """
+        # Get project context
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+
+        # Resolve task ID
+        try:
+            resolved_id = resolve_task_id_for_mcp(ctx.task_manager, parent_task_id, project_id)
+        except (TaskNotFoundError, ValueError) as e:
+            return {"error": f"Task not found: {e}"}
+
+        # Get task and check for pending spec
+        task = ctx.task_manager.get_task(resolved_id)
+        if not task:
+            return {"error": f"Task {parent_task_id} not found"}
+
+        if task.expansion_status != "pending":
+            return {
+                "error": f"Task has no pending expansion spec (status: {task.expansion_status})"
+            }
+
+        if not task.expansion_context:
+            return {"error": "Task has no expansion_context"}
+
+        # Parse spec
+        try:
+            spec = json.loads(task.expansion_context)
+        except json.JSONDecodeError as e:
+            return {"error": f"Invalid expansion_context JSON: {e}"}
+
+        subtasks = spec.get("subtasks", [])
+        if not subtasks:
+            return {"error": "No subtasks in spec"}
+
+        # Create subtasks atomically - clean up on failure
+        created_tasks = []
+        created_refs = []
+
+        try:
+            for subtask in subtasks:
+                result = ctx.task_manager.create_task_with_decomposition(
+                    project_id=task.project_id,
+                    title=subtask["title"],
+                    description=subtask.get("description"),
+                    priority=subtask.get("priority", 2),
+                    task_type=subtask.get("task_type", "task"),
+                    parent_task_id=resolved_id,
+                    category=subtask.get("category"),
+                    validation_criteria=subtask.get("validation"),
+                    created_in_session_id=session_id,
+                )
+
+                # Get the task (create_task_with_decomposition returns dict with task dict)
+                subtask_id = result["task"]["id"]
+                created_task = ctx.task_manager.get_task(subtask_id)
+                created_tasks.append(created_task)
+
+                # Build ref
+                ref = f"#{created_task.seq_num}" if created_task.seq_num else created_task.id[:8]
+                created_refs.append(ref)
+        except Exception as e:
+            # Clean up any tasks created before failure
+            logger.error(f"Expansion failed after creating {len(created_tasks)} tasks: {e}")
+            for task_to_delete in created_tasks:
+                try:
+                    ctx.task_manager.delete_task(task_to_delete.id)
+                except Exception as delete_err:
+                    logger.warning(f"Failed to clean up task {task_to_delete.id}: {delete_err}")
+            return {"error": f"Expansion failed: {e}", "cleaned_up": len(created_tasks)}
+
+        # Wire dependencies
+        for i, subtask in enumerate(subtasks):
+            depends_on = subtask.get("depends_on", [])
+            for dep_idx in depends_on:
+                if 0 <= dep_idx < len(created_tasks):
+                    try:
+                        ctx.dep_manager.add_dependency(
+                            task_id=created_tasks[i].id,
+                            depends_on=created_tasks[dep_idx].id,
+                            dep_type="blocks",
+                        )
+                    except ValueError:
+                        pass  # Dependency already exists or invalid
+
+        # Wire parent blocked by all children
+        for created_task in created_tasks:
+            try:
+                ctx.dep_manager.add_dependency(
+                    task_id=resolved_id,
+                    depends_on=created_task.id,
+                    dep_type="blocks",
+                )
+            except ValueError:
+                pass  # Already exists
+
+        # Update parent task status
+        ctx.task_manager.update_task(
+            resolved_id,
+            is_expanded=True,
+            expansion_status="completed",
+            validation_criteria="All subtasks must be completed (status: closed).",
+        )
+
+        logger.info(
+            f"Executed expansion for task {parent_task_id}: created {len(created_tasks)} subtasks"
+        )
+
+        return {
+            "created": created_refs,
+            "count": len(created_refs),
+        }
+
+    async def get_expansion_spec(
+        task_id: str,
+    ) -> dict[str, Any]:
+        """Check for pending expansion spec (for resume after compaction).
+
+        Used by /gobby-expand skill to check if there's a pending expansion
+        that was interrupted and can be resumed.
+
+        Args:
+            task_id: Task ID to check
+
+        Returns:
+            {"pending": True, "spec": {...}} if pending expansion exists
+            {"pending": False} otherwise
+        """
+        # Get project context
+        project_ctx = get_project_context()
+        project_id = project_ctx.get("id") if project_ctx else None
+
+        # Resolve task ID
+        try:
+            resolved_id = resolve_task_id_for_mcp(ctx.task_manager, task_id, project_id)
+        except (TaskNotFoundError, ValueError) as e:
+            return {"error": f"Task not found: {e}"}
+
+        # Get task
+        task = ctx.task_manager.get_task(resolved_id)
+        if not task:
+            return {"error": f"Task {task_id} not found"}
+
+        # Check for pending expansion
+        if task.expansion_status == "pending" and task.expansion_context:
+            try:
+                spec = json.loads(task.expansion_context)
+                return {
+                    "pending": True,
+                    "spec": spec,
+                    "subtask_count": len(spec.get("subtasks", [])),
+                }
+            except json.JSONDecodeError:
+                return {"pending": False, "error": "Invalid expansion_context JSON"}
+
+        return {"pending": False}
+
+    # Register tools
+    registry.register(
+        name="save_expansion_spec",
+        description="Save expansion spec to task for later execution. Used by /gobby-expand skill.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "Task ID to expand (can be #N, path, or UUID)",
+                },
+                "spec": {
+                    "type": "object",
+                    "description": "Expansion specification containing subtasks array",
+                    "properties": {
+                        "subtasks": {
+                            "type": "array",
+                            "description": "List of subtask definitions",
+                            "items": {
+                                "type": "object",
+                                "properties": {
+                                    "title": {"type": "string"},
+                                    "category": {"type": "string"},
+                                    "depends_on": {
+                                        "type": "array",
+                                        "items": {"type": "integer"},
+                                    },
+                                    "validation": {"type": "string"},
+                                    "description": {"type": "string"},
+                                    "priority": {"type": "integer"},
+                                },
+                                "required": ["title"],
+                            },
+                        },
+                    },
+                    "required": ["subtasks"],
+                },
+            },
+            "required": ["task_id", "spec"],
+        },
+        func=save_expansion_spec,
+    )
+
+    registry.register(
+        name="execute_expansion",
+        description="Execute a saved expansion spec atomically. Creates subtasks with dependencies.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "parent_task_id": {
+                    "type": "string",
+                    "description": "Task ID with saved expansion spec",
+                },
+                "session_id": {
+                    "type": "string",
+                    "description": "Session ID for tracking created tasks",
+                },
+            },
+            "required": ["parent_task_id", "session_id"],
+        },
+        func=execute_expansion,
+    )
+
+    registry.register(
+        name="get_expansion_spec",
+        description="Check for pending expansion spec (for resume after session compaction).",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "Task ID to check",
+                },
+            },
+            "required": ["task_id"],
+        },
+        func=get_expansion_spec,
+    )
+
+    return registry

gobby/mcp_proxy/tools/tasks/_factory.py

@@ -8,7 +8,6 @@ from typing import TYPE_CHECKING
 
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 from gobby.mcp_proxy.tools.task_dependencies import create_dependency_registry
-from gobby.mcp_proxy.tools.task_expansion import create_expansion_registry
 from gobby.mcp_proxy.tools.task_github import create_github_sync_registry
 from gobby.mcp_proxy.tools.task_orchestration import create_orchestration_registry
 from gobby.mcp_proxy.tools.task_readiness import create_readiness_registry
@@ -16,13 +15,13 @@ from gobby.mcp_proxy.tools.task_sync import create_sync_registry
 from gobby.mcp_proxy.tools.task_validation import create_validation_registry
 from gobby.mcp_proxy.tools.tasks._context import RegistryContext
 from gobby.mcp_proxy.tools.tasks._crud import create_crud_registry
+from gobby.mcp_proxy.tools.tasks._expansion import create_expansion_registry
 from gobby.mcp_proxy.tools.tasks._lifecycle import create_lifecycle_registry
 from gobby.mcp_proxy.tools.tasks._search import create_search_registry
 from gobby.mcp_proxy.tools.tasks._session import create_session_registry
 from gobby.storage.tasks import LocalTaskManager
 from gobby.storage.worktrees import LocalWorktreeManager
 from gobby.sync.tasks import TaskSyncManager
-from gobby.tasks.expansion import TaskExpander
 from gobby.tasks.validation import TaskValidator
 
 if TYPE_CHECKING:
@@ -35,7 +34,6 @@ if TYPE_CHECKING:
 def create_task_registry(
     task_manager: LocalTaskManager,
     sync_manager: TaskSyncManager,
-    task_expander: TaskExpander | None = None,
     task_validator: TaskValidator | None = None,
     config: "DaemonConfig | None" = None,
     agent_runner: "AgentRunner | None" = None,
@@ -50,7 +48,6 @@ def create_task_registry(
     Args:
         task_manager: LocalTaskManager instance
         sync_manager: TaskSyncManager instance
-        task_expander: TaskExpander instance (optional)
         task_validator: TaskValidator instance (optional)
         config: DaemonConfig instance (optional)
         agent_runner: AgentRunner instance for external validator agent mode (optional)
@@ -66,7 +63,6 @@ def create_task_registry(
     ctx = RegistryContext(
         task_manager=task_manager,
         sync_manager=sync_manager,
-        task_expander=task_expander,
         task_validator=task_validator,
         agent_runner=agent_runner,
         config=config,
@@ -98,6 +94,11 @@ def create_task_registry(
     for tool_name, tool in search_registry._tools.items():
         registry._tools[tool_name] = tool
 
+    # Merge expansion tools (skill-based task decomposition)
+    expansion_registry = create_expansion_registry(ctx)
+    for tool_name, tool in expansion_registry._tools.items():
+        registry._tools[tool_name] = tool
+
     # Merge validation tools from extracted module (Strangler Fig pattern)
     validation_registry = create_validation_registry(
         task_manager=task_manager,
@@ -108,17 +109,6 @@ def create_task_registry(
     for tool_name, tool in validation_registry._tools.items():
         registry._tools[tool_name] = tool
 
-    # Merge expansion tools from extracted module (Strangler Fig pattern)
-    expansion_registry = create_expansion_registry(
-        task_manager=task_manager,
-        task_expander=task_expander,
-        task_validator=task_validator,
-        auto_generate_on_expand=ctx.auto_generate_on_expand,
-        resolve_tdd_mode=ctx.resolve_tdd_mode,
-    )
-    for tool_name, tool in expansion_registry._tools.items():
-        registry._tools[tool_name] = tool
-
     # Merge dependency tools from extracted module (Strangler Fig pattern)
     dependency_registry = create_dependency_registry(
         task_manager=task_manager,