gobby 0.2.5__py3-none-any.whl

gobby/mcp_proxy/tools/tasks/__init__.py

@@ -0,0 +1,25 @@
+"""Task tools package.
+
+This package provides MCP tools for task management. Re-exports maintain
+backwards compatibility with the original tasks.py module.
+
+Public API:
+    - create_task_registry: Factory function to create the task tool registry
+    - resolve_task_id_for_mcp: Resolve task references to UUIDs
+
+Internal (exported for test compatibility):
+    - SKIP_REASONS: Reasons that skip validation on close
+    - _infer_category: Infer task category from title/description
+"""
+
+from gobby.mcp_proxy.tools.tasks._factory import create_task_registry
+from gobby.mcp_proxy.tools.tasks._helpers import SKIP_REASONS, _infer_category
+from gobby.mcp_proxy.tools.tasks._resolution import resolve_task_id_for_mcp
+
+__all__ = [
+    "create_task_registry",
+    "resolve_task_id_for_mcp",
+    # Internal exports for backward compatibility
+    "SKIP_REASONS",
+    "_infer_category",
+]

gobby/mcp_proxy/tools/tasks/_context.py

@@ -0,0 +1,112 @@
+"""Registry context for task tools.
+
+Provides RegistryContext dataclass that bundles shared state and helpers
+used across task tool modules.
+"""
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from gobby.storage.projects import LocalProjectManager
+from gobby.storage.session_tasks import SessionTaskManager
+from gobby.storage.task_dependencies import TaskDependencyManager
+from gobby.storage.tasks import LocalTaskManager
+from gobby.utils.project_context import get_project_context
+from gobby.workflows.definitions import WorkflowState
+from gobby.workflows.state_manager import WorkflowStateManager
+
+if TYPE_CHECKING:
+    from gobby.agents.runner import AgentRunner
+    from gobby.config.app import DaemonConfig
+    from gobby.config.tasks import TaskValidationConfig
+    from gobby.sync.tasks import TaskSyncManager
+    from gobby.tasks.expansion import TaskExpander
+    from gobby.tasks.validation import TaskValidator
+
+
+@dataclass
+class RegistryContext:
+    """Shared context for task tool registries.
+
+    Bundles managers, config, and helper methods used across all task tools.
+    """
+
+    # Core managers
+    task_manager: LocalTaskManager
+    sync_manager: "TaskSyncManager"
+
+    # Optional managers
+    task_expander: "TaskExpander | None" = None
+    task_validator: "TaskValidator | None" = None
+    agent_runner: "AgentRunner | None" = None
+    config: "DaemonConfig | None" = None
+
+    # Derived managers (initialized in __post_init__)
+    dep_manager: TaskDependencyManager = field(init=False)
+    session_task_manager: SessionTaskManager = field(init=False)
+    workflow_state_manager: WorkflowStateManager = field(init=False)
+    project_manager: LocalProjectManager = field(init=False)
+
+    # Config settings (initialized in __post_init__)
+    show_result_on_create: bool = field(init=False)
+    auto_generate_on_expand: bool = field(init=False)
+    tdd_mode_config: bool = field(init=False)
+    validation_config: "TaskValidationConfig | None" = field(init=False)
+
+    def __post_init__(self) -> None:
+        """Initialize derived managers and config settings."""
+        # Initialize managers from task_manager's database connection
+        db = self.task_manager.db
+        self.dep_manager = TaskDependencyManager(db)
+        self.session_task_manager = SessionTaskManager(db)
+        self.workflow_state_manager = WorkflowStateManager(db)
+        self.project_manager = LocalProjectManager(db)
+
+        # Initialize config settings
+        self.show_result_on_create = False
+        self.auto_generate_on_expand = True
+        self.tdd_mode_config = False
+        self.validation_config = None
+
+        if self.config is not None:
+            tasks_config = self.config.get_gobby_tasks_config()
+            self.show_result_on_create = tasks_config.show_result_on_create
+            self.validation_config = tasks_config.validation
+            self.auto_generate_on_expand = self.validation_config.auto_generate_on_expand
+            self.tdd_mode_config = tasks_config.expansion.tdd_mode
+
+    def get_project_repo_path(self, project_id: str | None) -> str | None:
+        """Get the repo_path for a project by ID."""
+        if not project_id:
+            return None
+        project = self.project_manager.get(project_id)
+        return project.repo_path if project else None
+
+    def get_current_project_id(self) -> str | None:
+        """Get the current project ID from context, or None if not in a project."""
+        ctx = get_project_context()
+        if ctx and ctx.get("id"):
+            project_id: str = ctx["id"]
+            return project_id
+        return None
+
+    def get_workflow_state(self, session_id: str | None) -> WorkflowState | None:
+        """Get workflow state for a session, if available."""
+        if not session_id:
+            return None
+        return self.workflow_state_manager.get_state(session_id)
+
+    def resolve_tdd_mode(self, session_id: str | None) -> bool:
+        """
+        Resolve tdd_mode from workflow state > config hierarchy.
+
+        Returns:
+            True if TDD mode is enabled, False otherwise.
+        """
+        # Check workflow state first (takes precedence)
+        state = self.get_workflow_state(session_id)
+        if state and "tdd_mode" in state.variables:
+            return bool(state.variables["tdd_mode"])
+
+        # Fall back to config
+        return self.tdd_mode_config

gobby/mcp_proxy/tools/tasks/_crud.py

@@ -0,0 +1,516 @@
+"""CRUD operations for task management.
+
+Provides core task operations: create, get, update, list, and tree building.
+"""
+
+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.tasks import TaskNotFoundError
+from gobby.utils.project_context import get_project_context
+from gobby.utils.project_init import initialize_project
+
+
+def create_crud_registry(ctx: RegistryContext) -> InternalToolRegistry:
+    """Create a registry with task CRUD tools.
+
+    Args:
+        ctx: Shared registry context
+
+    Returns:
+        InternalToolRegistry with CRUD tools registered
+    """
+    registry = InternalToolRegistry(
+        name="gobby-tasks-crud",
+        description="Task CRUD operations",
+    )
+
+    async def create_task(
+        title: str,
+        session_id: str,
+        description: str | None = None,
+        priority: int = 2,
+        task_type: str = "task",
+        parent_task_id: str | None = None,
+        blocks: list[str] | None = None,
+        labels: list[str] | None = None,
+        category: str | None = None,
+        validation_criteria: str | None = None,
+    ) -> dict[str, Any]:
+        """Create a single task in the current project.
+
+        This tool creates exactly ONE task. Auto-decomposition of multi-step
+        descriptions is disabled. Use expand_task for complex decompositions.
+
+        Args:
+            title: Task title
+            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
+            labels: List of labels
+            category: Task domain category (test, code, document, research, config, manual)
+            validation_criteria: Acceptance criteria for validating completion.
+
+        Returns:
+            Created task dict with id (minimal) or full task details based on config.
+        """
+        # Get current project context which is required for task creation
+        project_ctx = get_project_context()
+        if project_ctx and project_ctx.get("id"):
+            project_id = project_ctx["id"]
+        else:
+            init_result = initialize_project()
+            project_id = init_result.project_id
+
+        # Resolve parent_task_id if it's a reference format
+        if parent_task_id:
+            try:
+                parent_task_id = resolve_task_id_for_mcp(
+                    ctx.task_manager, parent_task_id, project_id
+                )
+            except (TaskNotFoundError, ValueError) as e:
+                return {"error": f"Invalid parent_task_id: {e}"}
+
+        # Auto-infer category if not provided
+        effective_category = category
+        if effective_category is None:
+            effective_category = _infer_category(title, description)
+
+        # Create task
+        create_result = ctx.task_manager.create_task_with_decomposition(
+            project_id=project_id,
+            title=title,
+            description=description,
+            priority=priority,
+            task_type=task_type,
+            parent_task_id=parent_task_id,
+            labels=labels,
+            category=effective_category,
+            validation_criteria=validation_criteria,
+            created_in_session_id=session_id,
+        )
+
+        task = ctx.task_manager.get_task(create_result["task"]["id"])
+
+        # Handle 'blocks' argument if provided (syntactic sugar)
+        if blocks:
+            for blocked_id in blocks:
+                ctx.dep_manager.add_dependency(task.id, blocked_id, "blocks")
+
+        # Return minimal or full result based on config
+        if ctx.show_result_on_create:
+            result = task.to_dict()
+        else:
+            result = {
+                "id": task.id,
+                "seq_num": task.seq_num,
+                "ref": f"#{task.seq_num}",
+            }
+
+        return result
+
+    registry.register(
+        name="create_task",
+        description="Create a new task in the current project.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "title": {"type": "string", "description": "Task title"},
+                "description": {
+                    "type": "string",
+                    "description": "Detailed description",
+                    "default": None,
+                },
+                "priority": {
+                    "type": "integer",
+                    "description": "Priority level (1=High, 2=Medium, 3=Low)",
+                    "default": 2,
+                },
+                "task_type": {
+                    "type": "string",
+                    "description": "Task type (task, bug, feature, epic)",
+                    "default": "task",
+                },
+                "parent_task_id": {
+                    "type": "string",
+                    "description": "Parent task reference: #N, N (seq_num), path (1.2.3), or UUID",
+                    "default": None,
+                },
+                "blocks": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of task IDs that this new task blocks (optional)",
+                    "default": None,
+                },
+                "labels": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "List of labels (optional)",
+                    "default": None,
+                },
+                "category": {
+                    "type": "string",
+                    "description": "Task domain: 'code' (implementation), 'config' (configuration files), 'docs' (documentation), 'test' (test-writing), 'research' (investigation), 'planning' (design/architecture), or 'manual' (manual verification).",
+                    "enum": ["code", "config", "docs", "test", "research", "planning", "manual"],
+                    "default": None,
+                },
+                "validation_criteria": {
+                    "type": "string",
+                    "description": "Acceptance criteria for validating task completion (optional). If not provided and generate_validation is True, criteria will be auto-generated.",
+                    "default": None,
+                },
+                "session_id": {
+                    "type": "string",
+                    "description": "Your session ID (from system context). Required to track which session created the task.",
+                },
+            },
+            "required": ["title", "session_id"],
+        },
+        func=create_task,
+    )
+
+    def get_task(task_id: str) -> dict[str, Any]:
+        """Get task details including dependencies."""
+        # 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 {"error": str(e), "found": False}
+        except ValueError as e:
+            return {"error": str(e), "found": False}
+
+        task = ctx.task_manager.get_task(resolved_id)
+        if not task:
+            return {"error": f"Task {task_id} not found", "found": False}
+
+        result: dict[str, Any] = task.to_dict()
+
+        # Enrich with dependency info
+        blockers = ctx.dep_manager.get_blockers(resolved_id)
+        blocking = ctx.dep_manager.get_blocking(resolved_id)
+
+        result["dependencies"] = {
+            "blocked_by": [b.to_dict() for b in blockers],
+            "blocking": [b.to_dict() for b in blocking],
+        }
+
+        return result
+
+    registry.register(
+        name="get_task",
+        description="Get task details including dependencies. Task ID can be #N (e.g., #1), path (e.g., 1.2.3), or UUID.",
+        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",
+                },
+            },
+            "required": ["task_id"],
+        },
+        func=get_task,
+    )
+
+    def update_task(
+        task_id: str,
+        title: str | None = None,
+        description: str | None = None,
+        status: str | None = None,
+        priority: int | None = None,
+        assignee: str | None = None,
+        labels: list[str] | None = None,
+        validation_criteria: str | None = None,
+        parent_task_id: str | None = None,
+        category: str | None = None,
+        workflow_name: str | None = None,
+        verification: str | None = None,
+        sequence_order: int | None = None,
+    ) -> dict[str, Any]:
+        """Update task fields."""
+        # 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 {"error": str(e)}
+        except ValueError as e:
+            return {"error": str(e)}
+
+        # Build kwargs only for non-None values to avoid overwriting with NULL
+        kwargs: dict[str, Any] = {}
+        if title is not None:
+            kwargs["title"] = title
+        if description is not None:
+            kwargs["description"] = description
+        if status is not None:
+            kwargs["status"] = status
+        if priority is not None:
+            kwargs["priority"] = priority
+        if assignee is not None:
+            kwargs["assignee"] = assignee
+        if labels is not None:
+            kwargs["labels"] = labels
+        if validation_criteria is not None:
+            kwargs["validation_criteria"] = validation_criteria
+        if parent_task_id is not None:
+            # Empty string means "clear parent" - convert to None for storage layer
+            # Also resolve parent_task_id if it's a reference format
+            if parent_task_id:
+                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
+            else:
+                kwargs["parent_task_id"] = None
+        if category is not None:
+            kwargs["category"] = category
+        if workflow_name is not None:
+            kwargs["workflow_name"] = workflow_name
+        if verification is not None:
+            kwargs["verification"] = verification
+        if sequence_order is not None:
+            kwargs["sequence_order"] = sequence_order
+
+        task = ctx.task_manager.update_task(resolved_id, **kwargs)
+        if not task:
+            return {"error": f"Task {task_id} not found"}
+        return {}
+
+    registry.register(
+        name="update_task",
+        description="Update task fields.",
+        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",
+                },
+                "title": {"type": "string", "description": "New title", "default": None},
+                "description": {
+                    "type": "string",
+                    "description": "New description",
+                    "default": None,
+                },
+                "status": {
+                    "type": "string",
+                    "description": "New status (open, in_progress, review, closed)",
+                    "default": None,
+                },
+                "priority": {"type": "integer", "description": "New priority", "default": None},
+                "assignee": {"type": "string", "description": "New assignee", "default": None},
+                "labels": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "description": "New labels list",
+                    "default": None,
+                },
+                "validation_criteria": {
+                    "type": "string",
+                    "description": "Acceptance criteria for validating task completion",
+                    "default": None,
+                },
+                "parent_task_id": {
+                    "type": "string",
+                    "description": "Parent task reference: #N, N (seq_num), path (1.2.3), or UUID. Empty string clears parent.",
+                    "default": None,
+                },
+                "category": {
+                    "type": "string",
+                    "description": "Task domain: 'code' (implementation), 'config' (configuration files), 'docs' (documentation), 'test' (test-writing), 'research' (investigation), 'planning' (design/architecture), or 'manual' (manual verification).",
+                    "enum": ["code", "config", "docs", "test", "research", "planning", "manual"],
+                    "default": None,
+                },
+                "workflow_name": {
+                    "type": "string",
+                    "description": "Workflow name for execution context",
+                    "default": None,
+                },
+                "verification": {
+                    "type": "string",
+                    "description": "Verification steps or notes",
+                    "default": None,
+                },
+                "sequence_order": {
+                    "type": "integer",
+                    "description": "Order in a sequence of tasks",
+                    "default": None,
+                },
+            },
+            "required": ["task_id"],
+        },
+        func=update_task,
+    )
+
+    def list_tasks(
+        status: str | list[str] | None = None,
+        priority: int | None = None,
+        task_type: str | None = None,
+        assignee: str | None = None,
+        label: str | None = None,
+        parent_task_id: str | None = None,
+        title_like: str | None = None,
+        limit: int = 50,
+        all_projects: bool = False,
+    ) -> dict[str, Any]:
+        """List tasks with optional filters."""
+        # Filter by current project unless all_projects is True
+        project_id = None if all_projects else ctx.get_current_project_id()
+
+        # Resolve parent_task_id if it's a reference format
+        if parent_task_id:
+            try:
+                parent_task_id = resolve_task_id_for_mcp(
+                    ctx.task_manager, parent_task_id, project_id
+                )
+            except (TaskNotFoundError, ValueError) as e:
+                return {"error": f"Invalid parent_task_id: {e}", "tasks": [], "count": 0}
+
+        # Handle comma-separated status string
+        status_filter: str | list[str] | None = status
+        if isinstance(status, str) and "," in status:
+            status_filter = [s.strip() for s in status.split(",")]
+
+        tasks = ctx.task_manager.list_tasks(
+            status=status_filter,
+            priority=priority,
+            task_type=task_type,
+            assignee=assignee,
+            label=label,
+            parent_task_id=parent_task_id,
+            title_like=title_like,
+            limit=limit,
+            project_id=project_id,
+        )
+        return {"tasks": [t.to_brief() for t in tasks], "count": len(tasks)}
+
+    registry.register(
+        name="list_tasks",
+        description="List tasks with optional filters.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "status": {
+                    "oneOf": [{"type": "string"}, {"type": "array", "items": {"type": "string"}}],
+                    "description": "Filter by status. Can be a single status, array of statuses, or comma-separated string (e.g., 'open,in_progress')",
+                    "default": None,
+                },
+                "priority": {
+                    "type": "integer",
+                    "description": "Filter by priority",
+                    "default": None,
+                },
+                "task_type": {
+                    "type": "string",
+                    "description": "Filter by task type",
+                    "default": None,
+                },
+                "assignee": {
+                    "type": "string",
+                    "description": "Filter by assignee",
+                    "default": None,
+                },
+                "label": {
+                    "type": "string",
+                    "description": "Filter by label presence",
+                    "default": None,
+                },
+                "parent_task_id": {
+                    "type": "string",
+                    "description": "Filter by parent task: #N, N (seq_num), path (1.2.3), or UUID",
+                    "default": None,
+                },
+                "title_like": {
+                    "type": "string",
+                    "description": "Filter by title (fuzzy match)",
+                    "default": None,
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Max number of tasks to return",
+                    "default": 50,
+                },
+                "all_projects": {
+                    "type": "boolean",
+                    "description": "If true, list tasks from all projects instead of just the current project",
+                    "default": False,
+                },
+            },
+        },
+        func=list_tasks,
+    )
+
+    return registry
+
+
+def build_task_tree(
+    ctx: RegistryContext,
+    tree: dict[str, Any],
+    session_id: str,
+) -> dict[str, Any]:
+    """Create an entire task tree in one call.
+
+    Creates tasks with parent-child relationships and wires dependencies
+    based on `depends_on` title references within siblings.
+
+    This is an internal helper function, NOT registered as an MCP tool.
+    Agents should use expand_task with iterative mode for tree expansion.
+
+    Args:
+        ctx: Registry context
+        tree: JSON tree structure with title, task_type, children, depends_on
+        session_id: Your session ID for tracking (REQUIRED)
+
+    Returns:
+        Dict with success status, tasks_created count, epic_ref, task_refs
+
+    Example tree:
+        {
+            "title": "Epic Title",
+            "task_type": "epic",
+            "children": [
+                {
+                    "title": "Phase 1",
+                    "children": [
+                        {"title": "Task A", "category": "code"},
+                        {"title": "Task B", "category": "code", "depends_on": ["Task A"]}
+                    ]
+                }
+            ]
+        }
+    """
+    from gobby.tasks.tree_builder import TaskTreeBuilder
+
+    # Get current project context
+    project_ctx = get_project_context()
+    if project_ctx and project_ctx.get("id"):
+        project_id = project_ctx["id"]
+    else:
+        init_result = initialize_project()
+        project_id = init_result.project_id
+
+    # Build the tree
+    builder = TaskTreeBuilder(
+        task_manager=ctx.task_manager,
+        project_id=project_id,
+        session_id=session_id,
+    )
+    result = builder.build(tree)
+
+    response: dict[str, Any] = {
+        "success": len(result.errors) == 0,
+        "tasks_created": result.tasks_created,
+        "epic_ref": result.epic_ref,
+        "task_refs": result.task_refs,
+    }
+    if result.errors:
+        response["errors"] = result.errors
+
+    return response