add view_note tool

Signed-off-by: phernandez <[email protected]>

Author: phernandez

src/basic_memory/mcp/tools/__init__.py

@@ -11,6 +11,7 @@
 from basic_memory.mcp.tools.build_context import build_context
 from basic_memory.mcp.tools.recent_activity import recent_activity
 from basic_memory.mcp.tools.read_note import read_note
+from basic_memory.mcp.tools.view_note import view_note
 from basic_memory.mcp.tools.write_note import write_note
 from basic_memory.mcp.tools.search import search_notes
 from basic_memory.mcp.tools.canvas import canvas
@@ -45,5 +46,6 @@
     "set_default_project",
     "switch_project",
     "sync_status",
+    "view_note",
     "write_note",
 ]

src/basic_memory/mcp/tools/view_note.py

@@ -0,0 +1,66 @@
+"""View note tool for Basic Memory MCP server."""
+
+from textwrap import dedent
+from typing import Optional
+
+from loguru import logger
+
+from basic_memory.mcp.server import mcp
+from basic_memory.mcp.tools.read_note import read_note
+
+
+@mcp.tool(
+    description="View a note as a formatted artifact for better readability.",
+)
+async def view_note(
+    identifier: str, page: int = 1, page_size: int = 10, project: Optional[str] = None
+) -> str:
+    """View a markdown note as a formatted artifact.
+
+    This tool reads a note using the same logic as read_note but displays the content
+    as a markdown artifact for better viewing experience in Claude Desktop.
+
+    After calling this tool, create an artifact using the returned content to display
+    the note in a readable format. The tool returns the note content that should be
+    used to create a markdown artifact.
+
+    Args:
+        identifier: The title or permalink of the note to view
+        page: Page number for paginated results (default: 1)
+        page_size: Number of items per page (default: 10)
+        project: Optional project name to read from. If not provided, uses current active project.
+
+    Returns:
+        The note content as a markdown artifact with a confirmation message.
+    """
+
+    logger.info(f"Viewing note: {identifier}")
+
+    # Call the existing read_note logic
+    content = await read_note(identifier, page, page_size, project)
+
+    # Check if this is an error message (note not found)
+    if "# Note Not Found:" in content:
+        return content  # Return error message directly instead of creating artifact
+
+    # Extract title from content if possible
+    title = identifier
+    lines = content.split("\n")
+    for line in lines:
+        if line.startswith("title:"):
+            # Extract title from frontmatter
+            title = line.split("title:", 1)[1].strip().strip('"').strip("'")
+            break
+        elif line.startswith("# "):
+            # Extract title from first heading
+            title = line[2:].strip()
+            break
+
+    # Return the artifact XML as part of the response
+    artifact = f'<artifact identifier="note-{hash(identifier) & 0x7FFFFFFF}" type="text/markdown" title="{title}">\n{content}\n</artifact>'
+
+    return dedent(f"""
+            <instructions>
+            Create an artifact using the returned artifact content to display the note in a readable format.
+            </instructions>
+            {artifact}\n\n✅ Note displayed as artifact: **{title}**""")

tests/mcp/test_tool_view_note.py

@@ -0,0 +1,302 @@
+"""Tests for view_note tool that exercise the full stack with SQLite."""
+
+from textwrap import dedent
+from unittest.mock import MagicMock, patch
+
+import pytest
+import pytest_asyncio
+
+from basic_memory.mcp.tools import write_note, view_note
+from basic_memory.schemas.search import SearchResponse, SearchItemType
+
+
+@pytest_asyncio.fixture
+async def mock_call_get():
+    """Mock for call_get to simulate different responses."""
+    with patch("basic_memory.mcp.tools.read_note.call_get") as mock:
+        # Default to 404 - not found
+        mock_response = MagicMock()
+        mock_response.status_code = 404
+        mock.return_value = mock_response
+        yield mock
+
+
+@pytest_asyncio.fixture
+async def mock_search():
+    """Mock for search tool."""
+    with patch("basic_memory.mcp.tools.read_note.search_notes") as mock:
+        # Default to empty results
+        mock.return_value = SearchResponse(results=[], current_page=1, page_size=1)
+        yield mock
+
+
+@pytest.mark.asyncio
+async def test_view_note_basic_functionality(app):
+    """Test viewing a note creates an artifact."""
+    # First create a note
+    await write_note(
+        title="Test View Note",
+        folder="test",
+        content="# Test View Note\n\nThis is test content for viewing.",
+    )
+
+    # View the note
+    result = await view_note("Test View Note")
+
+    # Should contain artifact XML
+    assert '<artifact identifier="note-' in result
+    assert 'type="text/markdown"' in result
+    assert 'title="Test View Note"' in result
+    assert "</artifact>" in result
+
+    # Should contain the note content within the artifact
+    assert "# Test View Note" in result
+    assert "This is test content for viewing." in result
+
+    # Should have confirmation message
+    assert "✅ Note displayed as artifact" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_with_frontmatter_title(app):
+    """Test viewing a note extracts title from frontmatter."""
+    # Create note with frontmatter
+    content = dedent("""
+        ---
+        title: "Frontmatter Title"
+        tags: [test]
+        ---
+        
+        # Frontmatter Title
+        
+        Content with frontmatter title.
+    """).strip()
+
+    await write_note(title="Frontmatter Title", folder="test", content=content)
+
+    # View the note
+    result = await view_note("Frontmatter Title")
+
+    # Should extract title from frontmatter
+    assert 'title="Frontmatter Title"' in result
+    assert "✅ Note displayed as artifact: **Frontmatter Title**" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_with_heading_title(app):
+    """Test viewing a note extracts title from first heading when no frontmatter."""
+    # Create note with heading but no frontmatter title
+    content = "# Heading Title\n\nContent with heading title."
+
+    await write_note(title="Heading Title", folder="test", content=content)
+
+    # View the note
+    result = await view_note("Heading Title")
+
+    # Should extract title from heading
+    assert 'title="Heading Title"' in result
+    assert "✅ Note displayed as artifact: **Heading Title**" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_unicode_content(app):
+    """Test viewing a note with Unicode content."""
+    content = "# Unicode Test 🚀\n\nThis note has emoji 🎉 and unicode ♠♣♥♦"
+
+    await write_note(title="Unicode Test 🚀", folder="test", content=content)
+
+    # View the note
+    result = await view_note("Unicode Test 🚀")
+
+    # Should handle Unicode properly
+    assert "🚀" in result
+    assert "🎉" in result
+    assert "♠♣♥♦" in result
+    assert '<artifact identifier="note-' in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_by_permalink(app):
+    """Test viewing a note by its permalink."""
+    await write_note(title="Permalink Test", folder="test", content="Content for permalink test.")
+
+    # View by permalink
+    result = await view_note("test/permalink-test")
+
+    # Should work with permalink
+    assert '<artifact identifier="note-' in result
+    assert "Content for permalink test." in result
+    assert "✅ Note displayed as artifact" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_with_memory_url(app):
+    """Test viewing a note using a memory:// URL."""
+    await write_note(
+        title="Memory URL Test",
+        folder="test",
+        content="Testing memory:// URL handling in view_note",
+    )
+
+    # View with memory:// URL
+    result = await view_note("memory://test/memory-url-test")
+
+    # Should work with memory:// URL
+    assert '<artifact identifier="note-' in result
+    assert "Testing memory:// URL handling in view_note" in result
+    assert "✅ Note displayed as artifact" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_not_found(app):
+    """Test viewing a non-existent note returns error without artifact."""
+    # Try to view non-existent note
+    result = await view_note("NonExistent Note")
+
+    # Should return error message without artifact
+    assert "# Note Not Found:" in result
+    assert "NonExistent Note" in result
+    assert "<artifact" not in result  # No artifact for errors
+    assert "Check Identifier Type" in result
+    assert "Search Instead" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_pagination(app):
+    """Test viewing a note with pagination parameters."""
+    await write_note(title="Pagination Test", folder="test", content="Content for pagination test.")
+
+    # View with pagination
+    result = await view_note("Pagination Test", page=1, page_size=5)
+
+    # Should work with pagination
+    assert '<artifact identifier="note-' in result
+    assert "Content for pagination test." in result
+    assert "✅ Note displayed as artifact" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_project_parameter(app):
+    """Test viewing a note with project parameter."""
+    await write_note(title="Project Test", folder="test", content="Content for project test.")
+
+    # View with explicit project (None uses current)
+    result = await view_note("Project Test", project=None)
+
+    # Should work with project parameter
+    assert '<artifact identifier="note-' in result
+    assert "Content for project test." in result
+    assert "✅ Note displayed as artifact" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_artifact_identifier_unique(app):
+    """Test that different notes get different artifact identifiers."""
+    # Create two notes
+    await write_note(title="Note One", folder="test", content="Content one")
+    await write_note(title="Note Two", folder="test", content="Content two")
+
+    # View both notes
+    result1 = await view_note("Note One")
+    result2 = await view_note("Note Two")
+
+    # Should have different artifact identifiers
+    import re
+
+    id1_match = re.search(r'identifier="(note-\d+)"', result1)
+    id2_match = re.search(r'identifier="(note-\d+)"', result2)
+
+    assert id1_match is not None
+    assert id2_match is not None
+    assert id1_match.group(1) != id2_match.group(1)
+
+
+@pytest.mark.asyncio
+async def test_view_note_fallback_identifier_as_title(app):
+    """Test that view_note uses identifier as title when no title is extractable."""
+    # Create a note with no clear title structure
+    await write_note(
+        title="Simple Note",
+        folder="test",
+        content="Just plain content with no headings or frontmatter title",
+    )
+
+    # View the note
+    result = await view_note("Simple Note")
+
+    # Should use identifier as fallback title
+    assert 'title="Simple Note"' in result
+    assert "✅ Note displayed as artifact: **Simple Note**" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_direct_success(mock_call_get):
+    """Test view_note with successful direct permalink lookup."""
+    # Setup mock for successful response with frontmatter
+    note_content = dedent("""
+        ---
+        title: "Test Note"
+        ---
+        # Test Note
+        
+        This is a test note.
+    """).strip()
+
+    mock_response = MagicMock()
+    mock_response.status_code = 200
+    mock_response.text = note_content
+    mock_call_get.return_value = mock_response
+
+    # Call the function
+    result = await view_note("test/test-note")
+
+    # Verify direct lookup was used
+    mock_call_get.assert_called_once()
+    assert "test/test-note" in mock_call_get.call_args[0][1]
+
+    # Verify result contains artifact
+    assert '<artifact identifier="note-' in result
+    assert 'title="Test Note"' in result
+    assert "This is a test note." in result
+    assert "✅ Note displayed as artifact: **Test Note**" in result
+
+
+@pytest.mark.asyncio
+async def test_view_note_title_search_fallback(mock_call_get, mock_search):
+    """Test view_note falls back to title search when direct lookup fails."""
+    # Setup mock for failed direct lookup
+    mock_call_get.side_effect = [
+        # First call fails (direct lookup)
+        MagicMock(status_code=404),
+        # Second call succeeds (after title search)
+        MagicMock(status_code=200, text="# Test Note\n\nThis is a test note."),
+    ]
+
+    # Setup mock for successful title search
+    mock_search.return_value = SearchResponse(
+        results=[
+            {
+                "id": 1,
+                "entity": "test/test-note",
+                "title": "Test Note",
+                "type": SearchItemType.ENTITY,
+                "permalink": "test/test-note",
+                "file_path": "test/test-note.md",
+                "score": 1.0,
+            }
+        ],
+        current_page=1,
+        page_size=1,
+    )
+
+    # Call the function
+    result = await view_note("Test Note")
+
+    # Verify title search was used
+    mock_search.assert_called_once()
+
+    # Verify result contains artifact with extracted title
+    assert '<artifact identifier="note-' in result
+    assert 'title="Test Note"' in result
+    assert "This is a test note." in result
+    assert "✅ Note displayed as artifact: **Test Note**" in result