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

gobby/mcp_proxy/tools/memory.py

@@ -3,7 +3,7 @@ Internal MCP tools for Gobby Memory System.
 
 Exposes functionality for:
 - Creating memories (create_memory)
-- Searching memories (search_memories, formerly recall_memory)
+- Searching memories (search_memories)
 - Deleting memories (delete_memory)
 - Listing memories (list_memories)
 - Getting memory details (get_memory)
@@ -144,29 +144,6 @@ def create_memory_registry(
         except Exception as e:
             return {"success": False, "error": str(e)}
 
-    # Backward compatibility alias for recall_memory -> search_memories
-    @registry.tool(
-        name="recall_memory",
-        description="[DEPRECATED: Use search_memories] Search memories based on query.",
-    )
-    def recall_memory(
-        query: str | None = None,
-        limit: int = 10,
-        min_importance: float | None = None,
-        tags_all: list[str] | None = None,
-        tags_any: list[str] | None = None,
-        tags_none: list[str] | None = None,
-    ) -> dict[str, Any]:
-        """Deprecated alias for search_memories. Use search_memories instead."""
-        return search_memories(  # type: ignore[no-any-return]
-            query=query,
-            limit=limit,
-            min_importance=min_importance,
-            tags_all=tags_all,
-            tags_any=tags_any,
-            tags_none=tags_none,
-        )
-
     @registry.tool(
         name="delete_memory",
         description="Delete a memory by ID.",

gobby/mcp_proxy/tools/metrics.py

@@ -11,20 +11,34 @@ via the downstream proxy pattern (call_tool).
 
 from typing import Any
 
+from gobby.conductor.token_tracker import SessionTokenTracker
 from gobby.mcp_proxy.metrics import ToolMetricsManager
 from gobby.mcp_proxy.tools.internal import InternalToolRegistry
 
 
-def create_metrics_registry(metrics_manager: ToolMetricsManager) -> InternalToolRegistry:
+def create_metrics_registry(
+    metrics_manager: ToolMetricsManager,
+    session_storage: Any | None = None,
+    daily_budget_usd: float = 50.0,
+) -> InternalToolRegistry:
     """
     Create a metrics tool registry with all metrics-related tools.
 
     Args:
         metrics_manager: ToolMetricsManager instance
+        session_storage: Optional LocalSessionManager for token/cost tracking
+        daily_budget_usd: Daily budget limit for token tracking (default: $50)
 
     Returns:
         InternalToolRegistry with metrics tools registered
     """
+    # Create token tracker if session storage is provided
+    token_tracker: SessionTokenTracker | None = None
+    if session_storage is not None:
+        token_tracker = SessionTokenTracker(
+            session_storage=session_storage,
+            daily_budget_usd=daily_budget_usd,
+        )
     registry = InternalToolRegistry(
         name="gobby-metrics",
         description="Tool metrics - query call counts, success rates, latency",
@@ -280,4 +294,54 @@ def create_metrics_registry(metrics_manager: ToolMetricsManager) -> InternalTool
         except Exception as e:
             return {"success": False, "error": str(e)}
 
+    # Token/cost tracking tools (only available if session_storage provided)
+    @registry.tool(
+        name="get_usage_report",
+        description="Get token and cost usage report for a specified time period.",
+    )
+    def get_usage_report(days: int = 1) -> dict[str, Any]:
+        """
+        Get usage report including token counts and costs.
+
+        Args:
+            days: Number of days to look back (default: 1 = today)
+
+        Returns:
+            Dictionary with usage summary
+        """
+        if token_tracker is None:
+            return {"success": False, "error": "Token tracking not configured"}
+
+        try:
+            summary = token_tracker.get_usage_summary(days=days)
+            return {
+                "success": True,
+                "usage": summary,
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+    @registry.tool(
+        name="get_budget_status",
+        description="Get current daily budget status including used amount and remaining budget.",
+    )
+    def get_budget_status() -> dict[str, Any]:
+        """
+        Get current budget status for today.
+
+        Returns:
+            Dictionary with budget info
+        """
+        if token_tracker is None:
+            return {"success": False, "error": "Token tracking not configured"}
+
+        try:
+            status = token_tracker.get_budget_status()
+            return {
+                "success": True,
+                "budget": status,
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
     return registry

gobby/mcp_proxy/tools/orchestration/__init__.py

@@ -5,6 +5,7 @@ Contains decomposed orchestration functionality:
 - monitor: Status monitoring tools (get_orchestration_status, poll_agent_status)
 - review: Review workflow tools (spawn_review_agent, process_completed_agents)
 - cleanup: Cleanup tools (cleanup_reviewed_worktrees, cleanup_stale_worktrees)
+- wait: Blocking wait tools (wait_for_task, wait_for_any_task, wait_for_all_tasks)
 - utils: Shared utilities
 """
 
@@ -13,11 +14,13 @@ from gobby.mcp_proxy.tools.orchestration.monitor import register_monitor
 from gobby.mcp_proxy.tools.orchestration.orchestrate import register_orchestrator
 from gobby.mcp_proxy.tools.orchestration.review import register_reviewer
 from gobby.mcp_proxy.tools.orchestration.utils import get_current_project_id
+from gobby.mcp_proxy.tools.orchestration.wait import register_wait
 
 __all__ = [
     "register_cleanup",
     "register_monitor",
     "register_orchestrator",
     "register_reviewer",
+    "register_wait",
     "get_current_project_id",
 ]

gobby/mcp_proxy/tools/orchestration/cleanup.py

@@ -26,6 +26,157 @@ def register_cleanup(
     default_project_id: str | None = None,
 ) -> None:
     """Register cleanup tools."""
+    from gobby.mcp_proxy.tools.tasks import resolve_task_id_for_mcp
+    from gobby.storage.tasks import TaskNotFoundError
+
+    async def approve_and_cleanup(
+        task_id: str,
+        push_branch: bool = False,
+        delete_worktree: bool = True,
+        force: bool = False,
+    ) -> dict[str, Any]:
+        """
+        Approve a reviewed task and clean up its worktree.
+
+        This tool transitions a task from "review" to "closed" status
+        and optionally deletes the associated worktree.
+
+        Args:
+            task_id: Task reference (#N, N, path, or UUID)
+            push_branch: Whether to push the branch to remote before cleanup
+            delete_worktree: Whether to delete the git worktree (default: True)
+            force: Force deletion even if worktree is dirty
+
+        Returns:
+            Dict with:
+            - success: Whether the operation succeeded
+            - task_status: New task status
+            - worktree_deleted: Whether worktree was deleted
+            - branch_pushed: Whether branch was pushed
+        """
+        # Resolve task ID
+        try:
+            resolved_task_id = resolve_task_id_for_mcp(task_manager, task_id)
+        except (TaskNotFoundError, ValueError) as e:
+            return {
+                "success": False,
+                "error": f"Task not found: {task_id} ({e})",
+            }
+
+        # Get the task
+        task = task_manager.get_task(resolved_task_id)
+        if task is None:
+            return {
+                "success": False,
+                "error": f"Task not found: {task_id}",
+            }
+
+        # Verify task is in review status
+        if task.status != "review":
+            return {
+                "success": False,
+                "error": f"Task must be in 'review' status to approve. Current status: {task.status}",
+            }
+
+        # Get associated worktree (if any)
+        worktree = worktree_storage.get_by_task(resolved_task_id)
+        branch_pushed = False
+        worktree_deleted = False
+
+        # Push branch to remote if requested
+        if push_branch and worktree and git_manager:
+            try:
+                push_result = git_manager._run_git(
+                    ["push", "origin", worktree.branch_name],
+                    timeout=60,
+                )
+                branch_pushed = push_result.returncode == 0
+                if not branch_pushed:
+                    logger.warning(f"Failed to push branch: {push_result.stderr}")
+            except Exception as e:
+                logger.warning(f"Error pushing branch: {e}")
+
+        # Update task status FIRST - before worktree deletion
+        try:
+            task_manager.update_task(
+                resolved_task_id,
+                status="closed",
+            )
+        except Exception as e:
+            return {
+                "success": False,
+                "error": f"Failed to update task status: {e}",
+                "task_id": resolved_task_id,
+                "worktree_deleted": False,
+            }
+
+        # Delete worktree if requested and available (after task is closed)
+        if delete_worktree and worktree:
+            if git_manager is None:
+                # No git manager - can't delete worktree, but continue
+                logger.warning("Git manager not available, skipping worktree deletion")
+            else:
+                try:
+                    delete_result = git_manager.delete_worktree(
+                        worktree_path=worktree.worktree_path,
+                        force=force,
+                        delete_branch=False,  # Keep branch for history
+                    )
+
+                    if delete_result.success:
+                        worktree_deleted = True
+                        # Mark worktree as merged and delete record
+                        worktree_storage.mark_merged(worktree.id)
+                        worktree_storage.delete(worktree.id)
+                    else:
+                        # Task is closed but worktree deletion failed
+                        logger.warning(f"Failed to delete worktree: {delete_result.message}")
+                except Exception as e:
+                    # Task is closed but worktree deletion failed
+                    logger.warning(f"Error deleting worktree: {e}")
+
+        return {
+            "success": True,
+            "task_id": resolved_task_id,
+            "task_status": "closed",
+            "worktree_deleted": worktree_deleted,
+            "branch_pushed": branch_pushed,
+            "message": f"Task {task_id} approved and marked as closed",
+        }
+
+    registry.register(
+        name="approve_and_cleanup",
+        description=(
+            "Approve a reviewed task and clean up its worktree. "
+            "Transitions task from 'review' to 'closed' status and deletes worktree."
+        ),
+        input_schema={
+            "type": "object",
+            "properties": {
+                "task_id": {
+                    "type": "string",
+                    "description": "Task reference: #N, N (seq_num), path (1.2.3), or UUID",
+                },
+                "push_branch": {
+                    "type": "boolean",
+                    "description": "Whether to push branch to remote before cleanup",
+                    "default": False,
+                },
+                "delete_worktree": {
+                    "type": "boolean",
+                    "description": "Whether to delete the git worktree",
+                    "default": True,
+                },
+                "force": {
+                    "type": "boolean",
+                    "description": "Force deletion even if worktree is dirty",
+                    "default": False,
+                },
+            },
+            "required": ["task_id"],
+        },
+        func=approve_and_cleanup,
+    )
 
     async def cleanup_reviewed_worktrees(
         parent_session_id: str,