fix: return consistent json for recent activity and delete errors

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

Author: phernandez

src/basic_memory/mcp/tools/delete_note.py

@@ -281,6 +281,16 @@ async def delete_note(
 
             except Exception as e:  # pragma: no cover
                 logger.error(f"Directory delete failed for '{identifier}': {e}")
+                if output_format == "json":
+                    return {
+                        "deleted": False,
+                        "is_directory": True,
+                        "identifier": identifier,
+                        "total_files": 0,
+                        "successful_deletes": 0,
+                        "failed_deletes": 0,
+                        "error": str(e),
+                    }
                 return f"""# Directory Delete Failed
 
 Error deleting directory '{identifier}': {str(e)}

src/basic_memory/mcp/tools/recent_activity.py

@@ -192,7 +192,7 @@ async def recent_activity(
         if output_format == "json":
             rows: list[dict] = []
             for project_name, project_activity in projects_activity.items():
-                rows.extend(_extract_recent_entity_rows(project_activity.activity, project_name))
+                rows.extend(_extract_recent_rows(project_activity.activity, project_name))
             return rows
 
         # Build summary stats
@@ -268,7 +268,7 @@ async def recent_activity(
             activity_data = GraphContext.model_validate(response.json())
 
             if output_format == "json":
-                return _extract_recent_entity_rows(activity_data)
+                return _extract_recent_rows(activity_data)
 
             # Format project-specific mode output
             return _format_project_output(resolved_project, activity_data, timeframe, type)
@@ -327,15 +327,13 @@ async def _get_project_activity(
     )
 
 
-def _extract_recent_entity_rows(
+def _extract_recent_rows(
     activity_data: GraphContext, project_name: Optional[str] = None
 ) -> list[dict]:
-    """Flatten GraphContext into a list of recent entity rows."""
+    """Flatten GraphContext into a list of recent rows."""
     rows: list[dict] = []
     for result in activity_data.results:
         primary = result.primary_result
-        if primary.type != "entity":
-            continue
         row = {
             "title": primary.title,
             "permalink": primary.permalink,

test-int/mcp/test_output_format_json_integration.py

@@ -8,6 +8,8 @@
 import pytest
 from fastmcp import Client
 
+from basic_memory.mcp.clients.knowledge import KnowledgeClient
+
 
 def _json_content(tool_result) -> dict | list:
     """Parse a FastMCP tool result content block into JSON."""
@@ -129,6 +131,65 @@ async def test_recent_activity_json_output(mcp_server, app, test_project):
             assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
 
 
+@pytest.mark.asyncio
+async def test_recent_activity_json_output_for_relation_and_observation_types(
+    mcp_server, app, test_project
+):
+    async with Client(mcp_server) as client:
+        await client.call_tool(
+            "write_note",
+            {
+                "project": test_project.name,
+                "title": "JSON Integration Type Source",
+                "directory": "json-int",
+                "content": (
+                    "# JSON Integration Type Source\n\n"
+                    "- [note] observation from source\n"
+                    "- links_to [[JSON Integration Type Target]]"
+                ),
+            },
+        )
+        await client.call_tool(
+            "write_note",
+            {
+                "project": test_project.name,
+                "title": "JSON Integration Type Target",
+                "directory": "json-int",
+                "content": "# JSON Integration Type Target\n\nBody",
+            },
+        )
+
+        relation_result = await client.call_tool(
+            "recent_activity",
+            {
+                "project": test_project.name,
+                "timeframe": "7d",
+                "type": "relation",
+                "output_format": "json",
+            },
+        )
+        relation_payload = _json_content(relation_result)
+        assert isinstance(relation_payload, list)
+        assert relation_payload
+        for item in relation_payload:
+            assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
+
+        observation_result = await client.call_tool(
+            "recent_activity",
+            {
+                "project": test_project.name,
+                "timeframe": "7d",
+                "type": "observation",
+                "output_format": "json",
+            },
+        )
+        observation_payload = _json_content(observation_result)
+        assert isinstance(observation_payload, list)
+        assert observation_payload
+        for item in observation_payload:
+            assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
+
+
 @pytest.mark.asyncio
 async def test_list_memory_projects_json_output(mcp_server, app, test_project):
     async with Client(mcp_server) as client:
@@ -213,6 +274,33 @@ async def test_delete_note_json_output(mcp_server, app, test_project):
         assert payload["file_path"]
 
 
+@pytest.mark.asyncio
+async def test_delete_note_directory_json_output_failure_is_structured(
+    mcp_server, app, test_project, monkeypatch
+):
+    async def mock_delete_directory(self, directory: str):
+        raise RuntimeError("simulated directory delete failure")
+
+    monkeypatch.setattr(KnowledgeClient, "delete_directory", mock_delete_directory)
+
+    async with Client(mcp_server) as client:
+        result = await client.call_tool(
+            "delete_note",
+            {
+                "project": test_project.name,
+                "identifier": "json-int",
+                "is_directory": True,
+                "output_format": "json",
+            },
+        )
+
+        payload = _json_content(result)
+        assert payload["deleted"] is False
+        assert payload["is_directory"] is True
+        assert payload["identifier"] == "json-int"
+        assert "simulated directory delete failure" in payload["error"]
+
+
 @pytest.mark.asyncio
 async def test_move_note_json_output(mcp_server, app, test_project):
     async with Client(mcp_server) as client:

tests/mcp/test_tool_json_output_modes.py

@@ -6,6 +6,7 @@
 
 import pytest
 
+from basic_memory.mcp.clients.knowledge import KnowledgeClient
 from basic_memory.mcp.tools import (
     build_context,
     create_memory_project,
@@ -148,6 +149,48 @@ async def test_recent_activity_text_and_json_modes(app, test_project):
         assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
 
 
+@pytest.mark.asyncio
+async def test_recent_activity_json_preserves_relation_and_observation_types(app, test_project):
+    await write_note.fn(
+        project=test_project.name,
+        title="Activity Type Source",
+        directory="mode-tests",
+        content=(
+            "# Activity Type Source\n\n"
+            "- [note] observation from source\n"
+            "- links_to [[Activity Type Target]]"
+        ),
+    )
+    await write_note.fn(
+        project=test_project.name,
+        title="Activity Type Target",
+        directory="mode-tests",
+        content="# Activity Type Target",
+    )
+
+    relation_json = await recent_activity.fn(
+        project=test_project.name,
+        type="relation",
+        timeframe="7d",
+        output_format="json",
+    )
+    assert isinstance(relation_json, list)
+    assert relation_json
+    for item in relation_json:
+        assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
+
+    observation_json = await recent_activity.fn(
+        project=test_project.name,
+        type="observation",
+        timeframe="7d",
+        output_format="json",
+    )
+    assert isinstance(observation_json, list)
+    assert observation_json
+    for item in observation_json:
+        assert set(["title", "permalink", "file_path", "created_at"]).issubset(item.keys())
+
+
 @pytest.mark.asyncio
 async def test_list_and_create_project_text_and_json_modes(app, test_project, tmp_path):
     list_text = await list_memory_projects.fn(output_format="text")
@@ -218,6 +261,28 @@ async def test_delete_note_text_and_json_modes(app, test_project):
     assert json_delete["file_path"]
 
 
+@pytest.mark.asyncio
+async def test_delete_directory_json_mode_returns_structured_error_on_failure(
+    app, test_project, monkeypatch
+):
+    async def mock_delete_directory(self, directory: str):
+        raise RuntimeError("simulated directory delete failure")
+
+    monkeypatch.setattr(KnowledgeClient, "delete_directory", mock_delete_directory)
+
+    json_delete = await delete_note.fn(
+        identifier="mode-tests",
+        is_directory=True,
+        project=test_project.name,
+        output_format="json",
+    )
+    assert isinstance(json_delete, dict)
+    assert json_delete["deleted"] is False
+    assert json_delete["is_directory"] is True
+    assert json_delete["identifier"] == "mode-tests"
+    assert "simulated directory delete failure" in json_delete["error"]
+
+
 @pytest.mark.asyncio
 async def test_move_note_text_and_json_modes(app, test_project):
     await write_note.fn(