chore: apply lint and formatting fixes

Apply automatic code formatting and linting fixes from ruff formatter.
These changes ensure consistent code style across the codebase without
functional modifications.

Changes:
- Fix whitespace and line ending consistency
- Apply consistent string quote formatting
- Remove trailing whitespace
- Format multi-line expressions for better readability

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: jope-bm <jope-bm@users.noreply.github.com>
Signed-off-by: Joe P <joe@basicmemory.com>

Author: jope-bm

src/basic_memory/mcp/tools/read_note.py

@@ -68,7 +68,7 @@ async def read_note(
 
     # Get the file via REST API - first try direct permalink lookup
     entity_path = memory_url_path(identifier)
-    
+
     # Validate path to prevent path traversal attacks
     project_path = active_project.home
     if not validate_project_path(entity_path, project_path):

src/basic_memory/utils.py

@@ -220,23 +220,23 @@ def validate_project_path(path: str, project_path: Path) -> bool:
     # Allow empty strings as they resolve to the project root
     if not path:
         return True
-    
+
     # Check for obvious path traversal patterns first
     if ".." in path or "~" in path:
         return False
-    
+
     # Check for Windows-style path traversal (even on Unix systems)
     if "\\.." in path or path.startswith("\\"):
         return False
-    
+
     # Block absolute paths (Unix-style starting with / or Windows-style with drive letters)
     if path.startswith("/") or (len(path) >= 2 and path[1] == ":"):
         return False
-    
+
     # Block paths with control characters (but allow whitespace that will be stripped)
-    if path.strip() and any(ord(c) < 32 and c not in [' ', '\t'] for c in path):
+    if path.strip() and any(ord(c) < 32 and c not in [" ", "\t"] for c in path):
         return False
-    
+
     try:
         resolved = (project_path / path).resolve()
         return resolved.is_relative_to(project_path.resolve())

tests/mcp/test_tool_move_note.py

@@ -650,7 +650,7 @@ async def test_move_note_allows_safe_paths(self, client):
             assert isinstance(result, str)
             # Should NOT contain security error message
             assert "Security Validation Error" not in result
-            
+
             # If it fails, it should be for other reasons like "already exists" or API errors
             if "Move Failed" in result:
                 assert "paths must stay within project boundaries" not in result
@@ -672,7 +672,7 @@ async def test_move_note_security_logging(self, client, caplog):
         )
 
         assert "# Move Failed - Security Validation Error" in result
-        
+
         # Check that security violation was logged
         # Note: This test may need adjustment based on the actual logging setup
         # The security validation should generate a warning log entry
@@ -710,7 +710,7 @@ async def test_move_note_current_directory_references_security(self, client):
         # Test current directory references (should be safe)
         safe_paths = [
             "./notes/file.md",
-            "folder/./file.md", 
+            "folder/./file.md",
             "./folder/subfolder/file.md",
         ]
 

tests/mcp/test_tool_read_content.py

@@ -139,18 +139,19 @@ async def test_read_content_allows_safe_paths_with_mocked_api(self, client):
             # Mock the API call to simulate a successful response
             with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
                 mock_response = MagicMock()
-                mock_response.headers = {
-                    "content-type": "text/markdown",
-                    "content-length": "100"
-                }
+                mock_response.headers = {"content-type": "text/markdown", "content-length": "100"}
                 mock_response.text = f"# Content for {safe_path}\nThis is test content."
                 mock_call_get.return_value = mock_response
-                
+
                 result = await read_content.fn(path=safe_path)
 
                 # Should succeed (not a security error)
                 assert isinstance(result, dict)
-                assert result["type"] != "error" or "paths must stay within project boundaries" not in result.get("error", "")
+                assert result[
+                    "type"
+                ] != "error" or "paths must stay within project boundaries" not in result.get(
+                    "error", ""
+                )
 
     @pytest.mark.asyncio
     async def test_read_content_memory_url_processing(self, client):
@@ -178,7 +179,7 @@ async def test_read_content_security_logging(self, client, caplog):
 
         assert result["type"] == "error"
         assert "paths must stay within project boundaries" in result["error"]
-        
+
         # Check that security violation was logged
         # Note: This test may need adjustment based on the actual logging setup
         # The security validation should generate a warning log entry
@@ -189,45 +190,47 @@ async def test_read_content_empty_path_security(self, client):
         # Mock the API call since empty path should be allowed (resolves to project root)
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
             mock_response = MagicMock()
-            mock_response.headers = {
-                "content-type": "text/markdown",
-                "content-length": "50"
-            }
+            mock_response.headers = {"content-type": "text/markdown", "content-length": "50"}
             mock_response.text = "# Root content"
             mock_call_get.return_value = mock_response
-            
+
             result = await read_content.fn(path="")
 
             assert isinstance(result, dict)
             # Empty path should not trigger security error (it's handled as project root)
-            assert result["type"] != "error" or "paths must stay within project boundaries" not in result.get("error", "")
+            assert result[
+                "type"
+            ] != "error" or "paths must stay within project boundaries" not in result.get(
+                "error", ""
+            )
 
     @pytest.mark.asyncio
     async def test_read_content_current_directory_references_security(self, client):
         """Test that current directory references are handled securely."""
         # Test current directory references (should be safe)
         safe_paths = [
             "./notes/file.md",
-            "folder/./file.md", 
+            "folder/./file.md",
             "./folder/subfolder/file.md",
         ]
 
         for safe_path in safe_paths:
             # Mock the API call for these safe paths
             with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
                 mock_response = MagicMock()
-                mock_response.headers = {
-                    "content-type": "text/markdown",
-                    "content-length": "100"
-                }
+                mock_response.headers = {"content-type": "text/markdown", "content-length": "100"}
                 mock_response.text = f"# Content for {safe_path}"
                 mock_call_get.return_value = mock_response
-                
+
                 result = await read_content.fn(path=safe_path)
 
                 assert isinstance(result, dict)
                 # Should NOT contain security error message
-                assert result["type"] != "error" or "paths must stay within project boundaries" not in result.get("error", "")
+                assert result[
+                    "type"
+                ] != "error" or "paths must stay within project boundaries" not in result.get(
+                    "error", ""
+                )
 
 
 class TestReadContentFunctionality:
@@ -246,13 +249,10 @@ async def test_read_content_text_file_success(self, client):
         # Mock the API call to simulate reading the file
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
             mock_response = MagicMock()
-            mock_response.headers = {
-                "content-type": "text/markdown",
-                "content-length": "100"
-            }
+            mock_response.headers = {"content-type": "text/markdown", "content-length": "100"}
             mock_response.text = "# Test Document\nThis is test content for reading."
             mock_call_get.return_value = mock_response
-            
+
             result = await read_content.fn(path="docs/test-document.md")
 
             assert isinstance(result, dict)
@@ -267,16 +267,16 @@ async def test_read_content_image_file_handling(self, client):
         # Mock the API call to simulate reading an image
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
             # Create a simple fake image data
-            fake_image_data = b'\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\rIDATx\x9cc\x00\x01\x00\x00\x05\x00\x01\r\n-\xdb\x00\x00\x00\x00IEND\xaeB`\x82'
-            
+            fake_image_data = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x08\x06\x00\x00\x00\x1f\x15\xc4\x89\x00\x00\x00\rIDATx\x9cc\x00\x01\x00\x00\x05\x00\x01\r\n-\xdb\x00\x00\x00\x00IEND\xaeB`\x82"
+
             mock_response = MagicMock()
             mock_response.headers = {
                 "content-type": "image/png",
-                "content-length": str(len(fake_image_data))
+                "content-length": str(len(fake_image_data)),
             }
             mock_response.content = fake_image_data
             mock_call_get.return_value = mock_response
-            
+
             # Mock PIL Image processing
             with patch("basic_memory.mcp.tools.read_content.PILImage") as mock_pil:
                 mock_img = MagicMock()
@@ -285,10 +285,10 @@ async def test_read_content_image_file_handling(self, client):
                 mock_img.mode = "RGB"
                 mock_img.getbands.return_value = ["R", "G", "B"]
                 mock_pil.open.return_value = mock_img
-                
+
                 with patch("basic_memory.mcp.tools.read_content.optimize_image") as mock_optimize:
                     mock_optimize.return_value = b"optimized_image_data"
-                    
+
                     result = await read_content.fn(path="assets/safe-image.png")
 
                     assert isinstance(result, dict)
@@ -302,24 +302,22 @@ async def test_read_content_with_project_parameter(self, client):
         """Test reading content with explicit project parameter."""
         # Mock the API call and project configuration
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
-            with patch("basic_memory.mcp.tools.read_content.get_active_project") as mock_get_project:
+            with patch(
+                "basic_memory.mcp.tools.read_content.get_active_project"
+            ) as mock_get_project:
                 # Mock project configuration
                 mock_project = MagicMock()
                 mock_project.project_url = "http://test"
                 mock_project.home = Path("/test/project")
                 mock_get_project.return_value = mock_project
-                
+
                 mock_response = MagicMock()
-                mock_response.headers = {
-                    "content-type": "text/plain",
-                    "content-length": "50"
-                }
+                mock_response.headers = {"content-type": "text/plain", "content-length": "50"}
                 mock_response.text = "Project-specific content"
                 mock_call_get.return_value = mock_response
-                
+
                 result = await read_content.fn(
-                    path="notes/project-file.txt",
-                    project="specific-project"
+                    path="notes/project-file.txt", project="specific-project"
                 )
 
                 assert isinstance(result, dict)
@@ -332,7 +330,7 @@ async def test_read_content_nonexistent_file_handling(self, client):
         # Mock API call to return 404
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
             mock_call_get.side_effect = Exception("File not found")
-            
+
             # This should pass security validation but fail on API call
             try:
                 result = await read_content.fn(path="docs/nonexistent-file.md")
@@ -348,15 +346,15 @@ async def test_read_content_binary_file_handling(self, client):
         # Mock the API call to simulate reading a binary file
         with patch("basic_memory.mcp.tools.read_content.call_get") as mock_call_get:
             binary_data = b"Binary file content with special bytes: \x00\x01\x02\x03"
-            
+
             mock_response = MagicMock()
             mock_response.headers = {
                 "content-type": "application/octet-stream",
-                "content-length": str(len(binary_data))
+                "content-length": str(len(binary_data)),
             }
             mock_response.content = binary_data
             mock_call_get.return_value = mock_response
-            
+
             result = await read_content.fn(path="files/safe-binary.bin")
 
             assert isinstance(result, dict)
@@ -399,14 +397,14 @@ async def test_read_content_url_encoded_attacks(self, client):
         for attack_path in encoded_attacks:
             try:
                 result = await read_content.fn(path=attack_path)
-                
+
                 # These may or may not be blocked depending on URL decoding,
                 # but should not cause security issues
                 assert isinstance(result, dict)
-                
+
                 # If not blocked by security validation, may fail at API level
                 # which is also acceptable
-                
+
             except Exception:
                 # Exception due to API failure or other issues is acceptable
                 # as long as no actual traversal occurs
@@ -435,7 +433,7 @@ async def test_read_content_very_long_attack_path(self, client):
         """Test handling of very long attack paths."""
         # Create a very long path traversal attack
         long_attack = "../" * 1000 + "etc/passwd"
-        
+
         result = await read_content.fn(path=long_attack)
 
         assert isinstance(result, dict)
@@ -458,4 +456,4 @@ async def test_read_content_case_variations_attacks(self, client):
 
             assert isinstance(result, dict)
             assert result["type"] == "error"
-            assert "paths must stay within project boundaries" in result["error"]
+            assert "paths must stay within project boundaries" in result["error"]

tests/mcp/test_tool_read_note.py

@@ -450,7 +450,9 @@ async def test_read_note_allows_safe_identifiers(self, app):
 
             assert isinstance(result, str)
             # Should not contain security error message
-            assert "# Error" not in result or "paths must stay within project boundaries" not in result
+            assert (
+                "# Error" not in result or "paths must stay within project boundaries" not in result
+            )
             # Should either succeed or fail for legitimate reasons (not found, etc.)
             # but not due to security validation
 
@@ -466,7 +468,7 @@ async def test_read_note_allows_legitimate_titles(self, app):
 
         # Test reading by title (should work)
         result = await read_note.fn("Security Test Note")
-        
+
         assert isinstance(result, str)
         # Should not be a security error
         assert "# Error" not in result or "paths must stay within project boundaries" not in result
@@ -506,7 +508,7 @@ async def test_read_note_security_logging(self, app, caplog):
 
         assert "# Error" in result
         assert "paths must stay within project boundaries" in result
-        
+
         # Check that security violation was logged
         # Note: This test may need adjustment based on the actual logging setup
         # The security validation should generate a warning log entry
@@ -539,7 +541,7 @@ async def test_read_note_preserves_functionality_with_security(self, app):
 
         # Test reading by permalink
         result = await read_note.fn("security-tests/full-feature-security-test-note")
-        
+
         # Should succeed normally (not a security error)
         assert isinstance(result, str)
         assert "# Error" not in result or "paths must stay within project boundaries" not in result
@@ -571,7 +573,7 @@ async def test_read_note_very_long_attack_identifier(self, app):
         """Test handling of very long attack identifiers."""
         # Create a very long path traversal attack
         long_attack_identifier = "../" * 1000 + "etc/malicious"
-        
+
         result = await read_note.fn(identifier=long_attack_identifier)
 
         assert isinstance(result, str)

tests/mcp/test_tool_write_note.py

@@ -864,7 +864,7 @@ async def test_write_note_current_directory_references_security(self, app):
         # Test current directory references (should be safe)
         safe_folders = [
             "./notes",
-            "folder/./subfolder", 
+            "folder/./subfolder",
             "./folder/subfolder",
         ]
 
@@ -912,7 +912,7 @@ async def test_write_note_security_logging(self, app, caplog):
 
         assert "# Error" in result
         assert "paths must stay within project boundaries" in result
-        
+
         # Check that security violation was logged
         # Note: This test may need adjustment based on the actual logging setup
         # The security validation should generate a warning log entry
@@ -950,16 +950,16 @@ async def test_write_note_preserves_functionality_with_security(self, app):
         assert "# Created note" in result
         assert "file_path: security-tests/Full Feature Security Test.md" in result
         assert "permalink: security-tests/full-feature-security-test" in result
-        
+
         # Should process observations and relations
         assert "## Observations" in result
         assert "## Relations" in result
         assert "## Tags" in result
-        
+
         # Should show proper counts
         assert "security: 1" in result
         assert "feature: 1" in result
-        
+
 
 class TestWriteNoteSecurityEdgeCases:
     """Test edge cases for write_note security validation."""
@@ -990,7 +990,7 @@ async def test_write_note_very_long_attack_folder(self, app):
         """Test handling of very long attack folder paths."""
         # Create a very long path traversal attack
         long_attack_folder = "../" * 1000 + "etc/malicious"
-        
+
         result = await write_note.fn(
             title="Long Attack Test",
             folder=long_attack_folder,