fix(sync): stabilize windows checksum writes

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

Author: phernandez

src/basic_memory/file_utils.py

@@ -114,8 +114,12 @@ async def write_file_atomic(path: FilePath, content: str) -> None:
     temp_path = path_obj.with_suffix(".tmp")
 
     try:
-        # Use aiofiles for non-blocking write
-        async with aiofiles.open(temp_path, mode="w", encoding="utf-8") as f:
+        # Trigger: Basic Memory writes markdown and metadata from normalized Python strings.
+        # Why: Windows text mode would translate "\n" into "\r\n", which makes the
+        #      persisted bytes diverge from the in-memory content we index and hash.
+        # Outcome: force LF on every platform so file bytes, checksums, and move detection
+        #          stay deterministic across local and CI environments.
+        async with aiofiles.open(temp_path, mode="w", encoding="utf-8", newline="\n") as f:
             await f.write(content)
 
         # Atomic rename (this is fast, doesn't need async)
@@ -168,7 +172,7 @@ async def format_markdown_builtin(path: Path) -> Optional[str]:
 
         # Only write if content changed
         if formatted_content != content:
-            async with aiofiles.open(path, mode="w", encoding="utf-8") as f:
+            async with aiofiles.open(path, mode="w", encoding="utf-8", newline="\n") as f:
                 await f.write(formatted_content)
 
         logger.debug(

src/basic_memory/services/file_service.py

@@ -208,15 +208,20 @@ async def write_file(self, path: FilePath, content: str) -> str:
 
                 await file_utils.write_file_atomic(full_path, content)
 
-                final_content = content
                 if self.app_config:
                     formatted_content = await file_utils.format_file(
                         full_path, self.app_config, is_markdown=self.is_markdown(path)
                     )
                     if formatted_content is not None:
-                        final_content = formatted_content  # pragma: no cover
-
-                checksum = await file_utils.compute_checksum(final_content)
+                        pass  # pragma: no cover
+
+                # Trigger: formatters and platform-specific text writers can change the
+                # persisted bytes even when the logical content string is the same.
+                # Why: sync and move detection compare against on-disk checksums, not
+                #      the pre-write Python string.
+                # Outcome: return the checksum of the actual stored file so callers do
+                #          not record a hash that immediately disagrees with the file.
+                checksum = await self.compute_checksum(full_path)
                 logger.debug(f"File write completed path={full_path}, {checksum=}")
                 return checksum
 
@@ -478,8 +483,12 @@ async def update_frontmatter_with_result(
                 if formatted_content is not None:
                     content_for_checksum = formatted_content  # pragma: no cover
 
+            # Trigger: frontmatter normalization may persist bytes that differ from the
+            # in-memory string because of formatter output or platform newline handling.
+            # Why: follow-up scans and checksum-based move detection read raw bytes from disk.
+            # Outcome: the returned checksum always matches the file that was just written.
             return FrontmatterUpdateResult(
-                checksum=await file_utils.compute_checksum(content_for_checksum),
+                checksum=await self.compute_checksum(full_path),
                 content=content_for_checksum,
             )
 

tests/services/test_file_service.py

@@ -4,6 +4,7 @@
 
 import pytest
 
+from basic_memory import file_utils
 from basic_memory.services.exceptions import FileOperationError
 from basic_memory.services.file_service import FileService
 
@@ -167,6 +168,33 @@ async def test_write_unicode_content(tmp_path: Path, file_service: FileService):
     assert content == test_content
 
 
+@pytest.mark.asyncio
+async def test_update_frontmatter_checksum_matches_persisted_bytes(
+    tmp_path: Path, file_service: FileService, monkeypatch
+):
+    """Frontmatter writes should hash the stored file, not the pre-write string."""
+    test_path = tmp_path / "note.md"
+    test_path.write_text("# Note\nBody\n", encoding="utf-8")
+
+    async def fake_write_file_atomic(path: Path, content: str) -> None:
+        # Trigger: simulate a writer that persists CRLF bytes like Windows text mode.
+        # Why: the regression happened when the stored bytes diverged from the LF string
+        #      used to build the checksum.
+        # Outcome: this test proves FileService returns the checksum for the stored file.
+        persisted = content.replace("\n", "\r\n").encode("utf-8")
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(persisted)
+
+    monkeypatch.setattr(file_utils, "write_file_atomic", fake_write_file_atomic)
+
+    result = await file_service.update_frontmatter_with_result(
+        test_path,
+        {"title": "Note", "type": "note"},
+    )
+
+    assert result.checksum == await file_service.compute_checksum(test_path)
+
+
 @pytest.mark.asyncio
 async def test_read_file_content(tmp_path: Path, file_service: FileService):
     """Test read_file_content returns just the content without checksum."""