feat: add file extension preservation check to move_note

- Fetch source entity to get original file extension
- Compare source and destination extensions
- Return error if extensions don't match
- Add tests for extension mismatch and preservation

This ensures file type consistency when moving notes.

Co-authored-by: Paul Hernandez <phernandez@users.noreply.github.com>

Author: github-actions[bot]

src/basic_memory/mcp/tools/move_note.py

@@ -460,6 +460,41 @@ async def move_note(
             All examples in Basic Memory expect file extensions to be explicitly provided.
             """).strip()
 
+    # Get the source entity to check its file extension
+    try:
+        # Fetch source entity information
+        url = f"{project_url}/knowledge/entities/{identifier}"
+        response = await call_get(client, url)
+        source_entity = EntityResponse.model_validate(response.json())
+
+        # Extract file extensions
+        source_ext = source_entity.file_path.split(".")[-1] if "." in source_entity.file_path else ""
+        dest_ext = destination_path.split(".")[-1] if "." in destination_path else ""
+
+        # Check if extensions match
+        if source_ext and dest_ext and source_ext.lower() != dest_ext.lower():
+            logger.warning(f"Move failed - file extension mismatch: source={source_ext}, dest={dest_ext}")
+            return dedent(f"""
+                # Move Failed - File Extension Mismatch
+
+                The destination file extension '.{dest_ext}' does not match the source file extension '.{source_ext}'.
+
+                To preserve file type consistency, the destination must have the same extension as the source.
+
+                ## Source file:
+                - Path: `{source_entity.file_path}`
+                - Extension: `.{source_ext}`
+
+                ## Try again with matching extension:
+                ```
+                move_note("{identifier}", "{destination_path.rsplit('.', 1)[0]}.{source_ext}")
+                ```
+                """).strip()
+    except Exception as e:
+        # If we can't fetch the source entity, log it but continue
+        # This might happen if the identifier is not yet resolved
+        logger.debug(f"Could not fetch source entity for extension check: {e}")
+
     try:
         # Prepare move request
         move_data = {

tests/mcp/test_tool_move_note.py

@@ -231,6 +231,69 @@ async def test_move_note_missing_file_extension(client):
     assert "Testing extension validation" in content
 
 
+@pytest.mark.asyncio
+async def test_move_note_file_extension_mismatch(client):
+    """Test that moving note with different extension is blocked."""
+    # Create initial note with .md extension
+    await write_note.fn(
+        title="MarkdownNote",
+        folder="source",
+        content="# Markdown Note\nThis is a markdown file.",
+    )
+
+    # Try to move with .txt extension
+    result = await move_note.fn(
+        identifier="source/markdown-note",
+        destination_path="target/renamed-note.txt",
+    )
+
+    # Should return error about extension mismatch
+    assert isinstance(result, str)
+    assert "# Move Failed - File Extension Mismatch" in result
+    assert "does not match the source file extension" in result
+    assert ".md" in result
+    assert ".txt" in result
+    assert "renamed-note.md" in result  # Should suggest correct extension
+
+    # Test that note still exists at original location with original extension
+    content = await read_note.fn("source/markdown-note")
+    assert "# Markdown Note" in content
+    assert "This is a markdown file" in content
+
+
+@pytest.mark.asyncio
+async def test_move_note_preserves_file_extension(client):
+    """Test that moving note with matching extension succeeds."""
+    # Create initial note with .md extension
+    await write_note.fn(
+        title="PreserveExtension",
+        folder="source",
+        content="# Preserve Extension\nTesting that extension is preserved.",
+    )
+
+    # Move with same .md extension
+    result = await move_note.fn(
+        identifier="source/preserve-extension",
+        destination_path="target/preserved-note.md",
+    )
+
+    # Should succeed
+    assert isinstance(result, str)
+    assert "✅ Note moved successfully" in result
+
+    # Verify note exists at new location with same extension
+    content = await read_note.fn("target/preserved-note")
+    assert "# Preserve Extension" in content
+    assert "Testing that extension is preserved" in content
+
+    # Verify old location no longer exists
+    try:
+        await read_note.fn("source/preserve-extension")
+        assert False, "Original note should not exist after move"
+    except Exception:
+        pass  # Expected
+
+
 @pytest.mark.asyncio
 async def test_move_note_destination_exists(client):
     """Test moving note to existing destination."""