fix(mcp): add workspace routing to delete_project

Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/mcp/tools/project_management.py

@@ -369,11 +369,11 @@ def _format_constrained_text(constrained_project: str) -> str:
     return result
 
 
-async def _resolve_create_project_workspace(
+async def _resolve_workspace_routing(
     workspace: str | None,
     context: Context | None,
 ) -> str | None:
-    """Resolve the create-project workspace selector to the routing tenant id."""
+    """Resolve an optional workspace selector to the routing tenant id."""
     if workspace is None:
         return None
 
@@ -389,7 +389,8 @@ async def _resolve_create_project_workspace(
     #   a friendly selector such as a slug, name, or tenant id.
     # Why: MCP callers should not need to paste UUIDs, but the transport still
     #   uses X-Workspace-ID with the tenant id as its routing authority.
-    # Outcome: resolve once at create time and pass only the tenant id downstream.
+    # Outcome: resolve once before the project-management request and pass only
+    #   the tenant id downstream.
     resolved_workspace = await resolve_workspace_parameter(workspace=workspace, context=context)
     return resolved_workspace.tenant_id
 
@@ -432,7 +433,7 @@ async def create_memory_project(
         create_memory_project("work-notes", "/home/user/work", set_default=True)
         create_memory_project("team-notes", "/team/notes", workspace="team-paul")
     """
-    workspace_id = await _resolve_create_project_workspace(workspace, context)
+    workspace_id = await _resolve_workspace_routing(workspace, context)
 
     # workspace targets a non-default cloud workspace at create time.
     # Trigger: caller passed workspace (e.g. a slug discovered via list_workspaces).
@@ -536,7 +537,11 @@ async def create_memory_project(
 @mcp.tool(
     annotations={"destructiveHint": True, "openWorldHint": False},
 )
-async def delete_project(project_name: str, context: Context | None = None) -> str:
+async def delete_project(
+    project_name: str,
+    workspace: str | None = None,
+    context: Context | None = None,
+) -> str:
     """Delete a Basic Memory project.
 
     Removes a project from the configuration and database. This does NOT delete
@@ -545,18 +550,25 @@ async def delete_project(project_name: str, context: Context | None = None) -> s
 
     Args:
         project_name: Name of the project to delete
+        workspace: Optional cloud workspace selector to delete the project from.
+            Slug is preferred for AI callers, but tenant_id and unique name are
+            also accepted. When omitted, the connection's default workspace is
+            used. Only meaningful in cloud mode; ignored for local projects.
 
     Returns:
         Confirmation message about project deletion
 
     Example:
         delete_project("old-project")
+        delete_project("team-project", workspace="team-paul")
 
     Warning:
         This action cannot be undone. The project will need to be re-added
         to access its content through Basic Memory again.
     """
-    async with get_client() as client:
+    workspace_id = await _resolve_workspace_routing(workspace, context)
+
+    async with get_client(workspace=workspace_id) as client:
         # Check if server is constrained to a specific project
         constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
         if constrained_project:

tests/mcp/test_tool_contracts.py

@@ -31,7 +31,7 @@
         "output_format",
     ],
     "delete_note": ["identifier", "is_directory", "project", "project_id", "output_format"],
-    "delete_project": ["project_name"],
+    "delete_project": ["project_name", "workspace"],
     "edit_note": [
         "identifier",
         "operation",

tests/mcp/test_tool_project_management.py

@@ -328,6 +328,204 @@ async def fake_get_client(*, workspace=None, project_name=None):
     assert captured["workspace"] is None
 
 
+@pytest.mark.asyncio
+async def test_delete_project_resolves_workspace_slug(app):
+    """A friendly workspace slug resolves to the tenant id used for delete routing."""
+    from contextlib import asynccontextmanager
+    import httpx
+
+    from basic_memory.mcp.clients import ProjectClient
+    from basic_memory.schemas.project_info import ProjectStatusResponse
+
+    target_project = _make_project(
+        "WS Project",
+        "/ws-project",
+        external_id="project-uuid",
+    )
+    captured: dict[str, str | None] = {}
+
+    @asynccontextmanager
+    async def fake_get_client(*, workspace=None, project_name=None):
+        captured["workspace"] = workspace
+        async with httpx.AsyncClient(base_url="http://testserver") as client:
+            yield client
+
+    fake_status = ProjectStatusResponse(
+        message="Project deleted",
+        status="success",
+        default=False,
+        old_project=target_project,
+    )
+
+    with (
+        patch(
+            "basic_memory.mcp.tools.project_management.get_client",
+            new=fake_get_client,
+        ),
+        patch(
+            "basic_memory.mcp.tools.project_management.is_factory_mode",
+            return_value=True,
+        ),
+        patch(
+            "basic_memory.mcp.tools.project_management.resolve_workspace_parameter",
+            new_callable=AsyncMock,
+            return_value=_make_workspace(
+                "tenant-abc-123",
+                "Team Paul",
+                workspace_type="organization",
+                slug="team-paul",
+            ),
+        ) as mock_resolve_workspace,
+        patch.object(
+            ProjectClient,
+            "list_projects",
+            new_callable=AsyncMock,
+            return_value=_make_list([target_project], default=None),
+        ),
+        patch.object(
+            ProjectClient,
+            "delete_project",
+            new_callable=AsyncMock,
+            return_value=fake_status,
+        ) as mock_delete_project,
+        patch(
+            "basic_memory.mcp.project_context.invalidate_workspace_project_index",
+            new_callable=AsyncMock,
+        ),
+    ):
+        result = await delete_project("WS Project", workspace="team-paul")
+
+    mock_resolve_workspace.assert_awaited_once_with(workspace="team-paul", context=None)
+    assert captured["workspace"] == "tenant-abc-123"
+    mock_delete_project.assert_awaited_once_with("project-uuid")
+    assert result.startswith("✓")
+
+
+@pytest.mark.asyncio
+async def test_delete_project_workspace_is_local_noop(app):
+    """Local delete accepts workspace without requiring cloud workspace discovery."""
+    from contextlib import asynccontextmanager
+    import httpx
+
+    from basic_memory.mcp.clients import ProjectClient
+    from basic_memory.schemas.project_info import ProjectStatusResponse
+
+    target_project = _make_project(
+        "Local WS Project",
+        "/local-ws-project",
+        external_id="local-project-uuid",
+    )
+    captured: dict[str, str | None] = {}
+
+    @asynccontextmanager
+    async def fake_get_client(*, workspace=None, project_name=None):
+        captured["workspace"] = workspace
+        async with httpx.AsyncClient(base_url="http://testserver") as client:
+            yield client
+
+    fake_status = ProjectStatusResponse(
+        message="Project deleted",
+        status="success",
+        default=False,
+        old_project=target_project,
+    )
+
+    with (
+        patch(
+            "basic_memory.mcp.tools.project_management.get_client",
+            new=fake_get_client,
+        ),
+        patch(
+            "basic_memory.mcp.tools.project_management.is_factory_mode",
+            return_value=False,
+        ),
+        patch(
+            "basic_memory.mcp.tools.project_management.has_cloud_credentials",
+            return_value=False,
+        ),
+        patch(
+            "basic_memory.mcp.tools.project_management.resolve_workspace_parameter",
+            new_callable=AsyncMock,
+        ) as mock_resolve_workspace,
+        patch.object(
+            ProjectClient,
+            "list_projects",
+            new_callable=AsyncMock,
+            return_value=_make_list([target_project], default=None),
+        ),
+        patch.object(
+            ProjectClient,
+            "delete_project",
+            new_callable=AsyncMock,
+            return_value=fake_status,
+        ),
+        patch(
+            "basic_memory.mcp.project_context.invalidate_workspace_project_index",
+            new_callable=AsyncMock,
+        ),
+    ):
+        await delete_project("Local WS Project", workspace="team-paul")
+
+    mock_resolve_workspace.assert_not_awaited()
+    assert captured["workspace"] == "team-paul"
+
+
+@pytest.mark.asyncio
+async def test_delete_project_default_workspace_is_none(app):
+    """When workspace is omitted, delete_project routes through the default workspace."""
+    from contextlib import asynccontextmanager
+    import httpx
+
+    from basic_memory.mcp.clients import ProjectClient
+    from basic_memory.schemas.project_info import ProjectStatusResponse
+
+    target_project = _make_project(
+        "Default WS Project",
+        "/default-ws-project",
+        external_id="default-project-uuid",
+    )
+    captured: dict[str, str | None] = {"workspace": "sentinel"}
+
+    @asynccontextmanager
+    async def fake_get_client(*, workspace=None, project_name=None):
+        captured["workspace"] = workspace
+        async with httpx.AsyncClient(base_url="http://testserver") as client:
+            yield client
+
+    fake_status = ProjectStatusResponse(
+        message="Project deleted",
+        status="success",
+        default=False,
+        old_project=target_project,
+    )
+
+    with (
+        patch(
+            "basic_memory.mcp.tools.project_management.get_client",
+            new=fake_get_client,
+        ),
+        patch.object(
+            ProjectClient,
+            "list_projects",
+            new_callable=AsyncMock,
+            return_value=_make_list([target_project], default=None),
+        ),
+        patch.object(
+            ProjectClient,
+            "delete_project",
+            new_callable=AsyncMock,
+            return_value=fake_status,
+        ),
+        patch(
+            "basic_memory.mcp.project_context.invalidate_workspace_project_index",
+            new_callable=AsyncMock,
+        ),
+    ):
+        await delete_project("Default WS Project")
+
+    assert captured["workspace"] is None
+
+
 # --- Cloud merge tests ---