fix: coerce list frontmatter values to strings for title and type fields

YAML block sequence syntax can cause PyYAML to parse scalar fields like
`title` and `type` as lists instead of strings. Downstream code calls
.strip()/.casefold() on these values, crashing with
"'list' object has no attribute 'strip'".

Add _coerce_to_string() helper that joins list items with ", " and apply
it in entity_parser.parse_markdown_content() and
entity_service.fast_edit_entity() where these fields are extracted.

Fixes basic-memory-cloud#376

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/markdown/entity_parser.py

@@ -88,6 +88,22 @@ def normalize_frontmatter_value(value: Any) -> Any:
     return value
 
 
+def _coerce_to_string(value: Any) -> str:
+    """Coerce a frontmatter value to a string.
+
+    YAML can parse scalar-looking fields as lists when the author uses block
+    sequence syntax.  For fields like ``title`` and ``type`` that *must* be
+    strings, this helper converts lists to a comma-separated string and any
+    other non-string type via ``str()``.
+    """
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        # Join list items, converting each to string first
+        return ", ".join(str(item) for item in value)
+    return str(value)
+
+
 def normalize_frontmatter_metadata(metadata: dict) -> dict:
     """Normalize all values in frontmatter metadata dict.
 
@@ -248,14 +264,21 @@ async def parse_markdown_content(
         # Normalize frontmatter values
         metadata = normalize_frontmatter_metadata(post.metadata)
 
-        # Ensure required fields have defaults
+        # Ensure required string fields are always strings.
+        # YAML can parse these as lists when authors use block sequence syntax
+        # (e.g. "title:\n  - My Title"), causing 'list' has no attribute 'strip'
+        # downstream.  See basic-memory-cloud#376.
         title = metadata.get("title")
+        if title is not None:
+            title = _coerce_to_string(title)
         if not title or title == "None":
             metadata["title"] = file_path.stem
         else:
             metadata["title"] = title
 
         note_type = metadata.get("type")
+        if note_type is not None:
+            note_type = _coerce_to_string(note_type)
         metadata["type"] = note_type if note_type is not None else "note"
 
         tags = parse_tags(metadata.get("tags", []))  # pyright: ignore

src/basic_memory/services/entity_service.py

@@ -19,7 +19,11 @@
     dump_frontmatter,
 )
 from basic_memory.markdown import EntityMarkdown
-from basic_memory.markdown.entity_parser import EntityParser, normalize_frontmatter_metadata
+from basic_memory.markdown.entity_parser import (
+    EntityParser,
+    _coerce_to_string,
+    normalize_frontmatter_metadata,
+)
 from basic_memory.markdown.utils import entity_model_from_markdown, schema_to_markdown
 from basic_memory.models import Entity as EntityModel
 from basic_memory.models import Observation, Relation
@@ -501,10 +505,11 @@ async def fast_edit_entity(
         if has_frontmatter(new_content):
             content_frontmatter = parse_frontmatter(new_content)
 
+            # Coerce to string — YAML may parse these as lists (cloud#376)
             if "title" in content_frontmatter:
-                update_data["title"] = content_frontmatter["title"]
+                update_data["title"] = _coerce_to_string(content_frontmatter["title"])
             if "type" in content_frontmatter:
-                update_data["note_type"] = content_frontmatter["type"]
+                update_data["note_type"] = _coerce_to_string(content_frontmatter["type"])
 
             if "permalink" in content_frontmatter:
                 content_markdown = self._build_frontmatter_markdown(

tests/markdown/test_date_frontmatter_parsing.py

@@ -5,65 +5,68 @@
 but later code expects strings and calls .strip() on them, causing AttributeError.
 """
 
+from textwrap import dedent
+
 import pytest
+
 from basic_memory.markdown.entity_parser import EntityParser
 
 
 @pytest.fixture
 def test_file_with_date(tmp_path):
     """Create a test file with date fields in frontmatter."""
     test_file = tmp_path / "test_note.md"
-    content = """---
-title: Test Note
-date: 2025-10-24
-created: 2025-10-24
-tags:
-  - python
-  - testing
----
-
-# Test Content
-
-This file has date fields in frontmatter that PyYAML will parse as datetime.date objects.
-"""
-    test_file.write_text(content)
+    test_file.write_text(dedent("""\
+        ---
+        title: Test Note
+        date: 2025-10-24
+        created: 2025-10-24
+        tags:
+          - python
+          - testing
+        ---
+
+        # Test Content
+
+        This file has date fields in frontmatter that PyYAML will parse as datetime.date objects.
+    """))
     return test_file
 
 
 @pytest.fixture
 def test_file_with_date_in_tags(tmp_path):
     """Create a test file with a date value in tags (edge case)."""
     test_file = tmp_path / "test_note_date_tags.md"
-    content = """---
-title: Test Note with Date Tags
-tags: 2025-10-24
----
+    test_file.write_text(dedent("""\
+        ---
+        title: Test Note with Date Tags
+        tags: 2025-10-24
+        ---
 
-# Test Content
+        # Test Content
 
-This file has a date value as tags, which will be parsed as datetime.date.
-"""
-    test_file.write_text(content)
+        This file has a date value as tags, which will be parsed as datetime.date.
+    """))
     return test_file
 
 
 @pytest.fixture
 def test_file_with_dates_in_tag_list(tmp_path):
     """Create a test file with dates in a tag list (edge case)."""
     test_file = tmp_path / "test_note_dates_in_list.md"
-    content = """---
-title: Test Note with Dates in Tags List
-tags:
-  - valid-tag
-  - 2025-10-24
-  - another-tag
----
-
-# Test Content
-
-This file has date values mixed into tags list.
-"""
-    test_file.write_text(content)
+    test_file.write_text(dedent("""\
+        ---
+        title: Test Note with Dates in Tags List
+        tags:
+          - valid-tag
+          - 2025-10-24
+          - another-tag
+        ---
+
+        # Test Content
+
+        This file has date values mixed into tags list.
+    """))
     return test_file
 
 
@@ -129,6 +132,83 @@ async def test_parse_file_with_dates_in_tag_list(test_file_with_dates_in_tag_lis
     assert "2025-10-24" in tags
 
 
+@pytest.mark.asyncio
+async def test_parse_file_with_list_frontmatter_fields(tmp_path):
+    """Test that list values in expected-string frontmatter fields are coerced to strings.
+
+    Reproduces basic-memory-cloud#376 where a markdown file has YAML list values
+    in frontmatter fields like 'title' or 'type' that downstream code expects
+    to be strings, causing 'list' object has no attribute 'strip'.
+    """
+    test_file = tmp_path / "test_list_fields.md"
+    test_file.write_text(dedent("""\
+        ---
+        title:
+          - Week 2 Discussion Post
+          - Alternate Title
+        tags:
+          - coursework
+          - sie-571
+        type:
+          - note
+          - assignment
+        some_field:
+          - item1
+          - item2
+        ---
+
+        # Content
+
+        Some body text.
+    """))
+
+    parser = EntityParser(tmp_path)
+    entity_markdown = await parser.parse_file(test_file)
+
+    # title must always be a string, even when YAML parses it as a list
+    title = entity_markdown.frontmatter.title
+    assert isinstance(title, str), f"Expected str, got {type(title)}"
+    assert "Week 2 Discussion Post" in title
+
+    # type must always be a string
+    note_type = entity_markdown.frontmatter.type
+    assert isinstance(note_type, str), f"Expected str, got {type(note_type)}"
+
+    # tags should still be a list (they're explicitly handled)
+    tags = entity_markdown.frontmatter.tags
+    assert isinstance(tags, list)
+    assert "coursework" in tags
+
+    # arbitrary list fields in metadata are preserved as lists
+    some_field = entity_markdown.frontmatter.metadata.get("some_field")
+    assert isinstance(some_field, list)
+    assert some_field == ["item1", "item2"]
+
+    # Verify title is safe for .strip() and .casefold() (the actual crash sites)
+    assert title.strip().casefold()
+
+
+@pytest.mark.asyncio
+async def test_parse_file_with_list_title_single_item(tmp_path):
+    """Test that a single-item list title is coerced to a plain string."""
+    test_file = tmp_path / "test_single_list_title.md"
+    test_file.write_text(dedent("""\
+        ---
+        title:
+          - My Single Title
+        ---
+
+        # Content
+    """))
+
+    parser = EntityParser(tmp_path)
+    entity_markdown = await parser.parse_file(test_file)
+
+    title = entity_markdown.frontmatter.title
+    assert isinstance(title, str)
+    assert title == "My Single Title"
+
+
 @pytest.mark.asyncio
 async def test_parse_file_with_various_yaml_types(tmp_path):
     """Test that various YAML types in frontmatter don't cause errors.
@@ -138,24 +218,24 @@ async def test_parse_file_with_various_yaml_types(tmp_path):
     when code expects strings and calls .strip().
     """
     test_file = tmp_path / "test_yaml_types.md"
-    content = """---
-title: Test YAML Types
-date: 2025-10-24
-priority: 1
-completed: true
-tags:
-  - python
-  - testing
-metadata:
-  author: Test User
-  version: 1.0
----
-
-# Test Content
-
-This file has various YAML types that need to be normalized.
-"""
-    test_file.write_text(content)
+    test_file.write_text(dedent("""\
+        ---
+        title: Test YAML Types
+        date: 2025-10-24
+        priority: 1
+        completed: true
+        tags:
+          - python
+          - testing
+        metadata:
+          author: Test User
+          version: 1.0
+        ---
+
+        # Test Content
+
+        This file has various YAML types that need to be normalized.
+    """))
 
     parser = EntityParser(tmp_path)
     entity_markdown = await parser.parse_file(test_file)
@@ -202,20 +282,17 @@ async def test_parse_file_with_datetime_objects(tmp_path):
     with time components (as parsed by PyYAML), ensuring they're converted to ISO format strings.
     """
     test_file = tmp_path / "test_datetime.md"
+    test_file.write_text(dedent("""\
+        ---
+        title: Test Datetime
+        created_at: 2025-10-24 14:30:00
+        updated_at: 2025-10-24T00:00:00
+        ---
 
-    # YAML datetime strings that PyYAML will parse as datetime objects
-    # Format: YYYY-MM-DD HH:MM:SS or YYYY-MM-DDTHH:MM:SS
-    content = """---
-title: Test Datetime
-created_at: 2025-10-24 14:30:00
-updated_at: 2025-10-24T00:00:00
----
+        # Test Content
 
-# Test Content
-
-This file has datetime values in frontmatter that PyYAML will parse as datetime objects.
-"""
-    test_file.write_text(content)
+        This file has datetime values in frontmatter that PyYAML will parse as datetime objects.
+    """))
 
     parser = EntityParser(tmp_path)
     entity_markdown = await parser.parse_file(test_file)