fix: re-add feature to read multiple notes

Author: phernandez

src/basic_memory/api/routers/resource_router.py

@@ -1,34 +1,115 @@
 """Routes for getting entity content."""
 
+import tempfile
 from pathlib import Path
 
-from fastapi import APIRouter, HTTPException
+from fastapi import APIRouter, HTTPException, BackgroundTasks
 from fastapi.responses import FileResponse
 from loguru import logger
 
-from basic_memory.deps import ProjectConfigDep, LinkResolverDep
+from basic_memory.deps import (
+    ProjectConfigDep,
+    LinkResolverDep,
+    SearchServiceDep,
+    EntityServiceDep,
+    FileServiceDep,
+)
+from basic_memory.repository.search_repository import SearchIndexRow
+from basic_memory.schemas.memory import normalize_memory_url
+from basic_memory.schemas.search import SearchQuery, SearchItemType
 
 router = APIRouter(prefix="/resource", tags=["resources"])
 
 
+def get_entity_ids(item: SearchIndexRow) -> list[int]:
+    match item.type:
+        case SearchItemType.ENTITY:
+            return [item.id]
+        case SearchItemType.OBSERVATION:
+            return [item.entity_id]
+        case SearchItemType.RELATION:
+            from_entity = item.from_id
+            to_entity = item.to_id
+            return [from_entity, to_entity] if to_entity else [from_entity]
+
+
 @router.get("/{identifier:path}")
 async def get_resource_content(
     config: ProjectConfigDep,
     link_resolver: LinkResolverDep,
+    search_service: SearchServiceDep,
+    entity_service: EntityServiceDep,
+    file_service: FileServiceDep,
+    background_tasks: BackgroundTasks,
     identifier: str,
 ) -> FileResponse:
     """Get resource content by identifier: name or permalink."""
-    logger.debug(f"Getting content for permalink: {identifier}")
+    logger.debug(f"Getting content for: {identifier}")
 
-    # Find entity by permalink
+    # Find single entity by permalink
     entity = await link_resolver.resolve_link(identifier)
-    if not entity:
-        raise HTTPException(status_code=404, detail=f"Entity not found: {identifier}")
-
-    file_path = Path(f"{config.home}/{entity.file_path}")
-    if not file_path.exists():
-        raise HTTPException(
-            status_code=404,
-            detail=f"File not found: {file_path}",
+    results = [entity] if entity else []
+
+    # search using the identifier as a permalink
+    if not results:
+        # if the identifier contains a wildcard, use GLOB search
+        query = (
+            SearchQuery(permalink_match=identifier)
+            if "*" in identifier
+            else SearchQuery(permalink=identifier)
         )
-    return FileResponse(path=file_path)
+        search_results = await search_service.search(query)
+        if not search_results:
+            raise HTTPException(status_code=404, detail=f"Resource not found: {identifier}")
+
+        # get the entities related to the search results
+        entity_ids = [id for result in search_results for id in get_entity_ids(result)]
+        results = await entity_service.get_entities_by_id(entity_ids)
+
+    # return single response
+    if len(results) == 1:
+        entity = results[0]
+        file_path = Path(f"{config.home}/{entity.file_path}")
+        if not file_path.exists():
+            raise HTTPException(
+                status_code=404,
+                detail=f"File not found: {file_path}",
+            )
+        return FileResponse(path=file_path)
+
+    # for multiple files, initialize a temporary file for writing the results
+    with tempfile.NamedTemporaryFile(delete=False, mode="w", suffix=".md") as tmp_file:
+        temp_file_path = tmp_file.name
+
+        for result in results:
+            # Read content for each entity
+            content = await file_service.read_entity_content(result)
+            memory_url = normalize_memory_url(result.permalink)
+            modified_date = result.updated_at.isoformat()
+            checksum = result.checksum[:8]
+
+            # Prepare the delimited content
+            response_content = f"--- {memory_url} {modified_date} {checksum}\n"
+            response_content += f"\n{content}\n"
+            response_content += "\n"
+
+            # Write content directly to the temporary file in append mode
+            tmp_file.write(response_content)
+
+        # Ensure all content is written to disk
+        tmp_file.flush()
+
+    # Schedule the temporary file to be deleted after the response
+    background_tasks.add_task(cleanup_temp_file, temp_file_path)
+
+    # Return the file response
+    return FileResponse(path=temp_file_path)
+
+
+def cleanup_temp_file(file_path: str):
+    """Delete the temporary file."""
+    try:
+        Path(file_path).unlink()  # Deletes the file
+        logger.debug(f"Temporary file deleted: {file_path}")
+    except Exception as e:  # pragma: no cover
+        logger.error(f"Error deleting temporary file {file_path}: {e}")

src/basic_memory/mcp/tools/notes.py

@@ -28,9 +28,29 @@ async def write_note(
 ) -> EntityResponse | str:
     """Write a markdown note to the knowledge base.
 
+    The content can include semantic observations and relations using markdown syntax.
+    Relations can be specified either explicitly or through inline wiki-style links:
+
+    Observations format:
+        `- [category] Observation text #tag1 #tag2 (optional context)`
+
+        Examples:
+        `- [design] Files are the source of truth #architecture (All state comes from files)`
+        `- [tech] Using SQLite for storage #implementation`
+        `- [note] Need to add error handling #todo`
+
+    Relations format:
+        - Explicit: `- relation_type [[Entity]] (optional context)`
+        - Inline: Any `[[Entity]]` reference creates a relation
+
+        Examples:
+        `- depends_on [[Content Parser]] (Need for semantic extraction)`
+        `- implements [[Search Spec]] (Initial implementation)`
+        `- This feature extends [[Base Design]] and uses [[Core Utils]]`
+
     Args:
         title: The title of the note
-        content: Markdown content for the note
+        content: Markdown content for the note, can include observations and relations
         folder: the folder where the file should be saved
         tags: Optional list of tags to categorize the note
         verbose: If True, returns full EntityResponse with semantic info
@@ -40,19 +60,32 @@ async def write_note(
         If verbose=True: EntityResponse with full semantic details
 
     Examples:
-        # Create a simple note
+        # Note with both explicit and inline relations
         write_note(
-            tile="Meeting Notes: Project Planning.md",
-            content="# Key Points\\n\\n- Discussed timeline\\n- Set priorities"
-            folder="notes"
+            title="Search Implementation",
+            content="# Search Component\\n\\n"
+                   "Implementation of the search feature, building on [[Core Search]].\\n\\n"
+                   "## Observations\\n"
+                   "- [tech] Using FTS5 for full-text search #implementation\\n"
+                   "- [design] Need pagination support #todo\\n\\n"
+                   "## Relations\\n"
+                   "- implements [[Search Spec]]\\n"
+                   "- depends_on [[Database Schema]]",
+            folder="docs/components"
         )
 
-        # Create note with tags
+        # Note with tags
         write_note(
-            title="Security Review",
-            content="# Findings\\n\\n1. Updated auth flow\\n2. Added rate limiting",
-            folder="security",
-            tags=["security", "development"]
+            title="Error Handling Design",
+            content="# Error Handling\\n\\n"
+                   "This design builds on [[Reliability Design]].\\n\\n"
+                   "## Approach\\n"
+                   "- [design] Use error codes #architecture\\n"
+                   "- [tech] Implement retry logic #implementation\\n\\n"
+                   "## Relations\\n"
+                   "- extends [[Base Error Handling]]",
+            folder="docs/design",
+            tags=["architecture", "reliability"]
         )
     """
     logger.info(f"Writing note folder:'{folder}' title: '{title}'")
@@ -76,26 +109,58 @@ async def write_note(
     return result if verbose else result.permalink
 
 
-@mcp.tool(description="Read a note's content by its title or permalink")
+@mcp.tool(description="Read note content by title, permalink, relation, or pattern")
 async def read_note(identifier: str) -> str:
-    """Get the markdown content of a note.
-    Uses the resource router to return the actual file content.
+    """Get note content in unified diff format.
+
+    The content is returned in a unified diff inspired format:
+    ```
+    --- memory://docs/example 2025-01-31T19:32:49 7d9f1c8b
+    <document content>
+    ```
+
+    Multiple documents (from relations or pattern matches) are separated by
+    additional headers.
 
     Args:
-        identifier: Note title or permalink
+        identifier: Can be one of:
+            - Note title ("Project Planning")
+            - Note permalink ("docs/example")
+            - Relation path ("docs/example/depends-on/other-doc")
+            - Pattern match ("docs/*-architecture")
 
     Returns:
-        The note's markdown content
+        Document content in unified diff format. For single documents, returns
+        just that document's content. For relations or pattern matches, returns
+        multiple documents separated by unified diff headers.
 
     Examples:
-        # Read by title
-        read_note("Meeting Notes: Project Planning")
+        # Single document
+        content = await read_note("Project Planning")
 
         # Read by permalink
-        read_note("notes/project-planning")
+        content = await read_note("docs/architecture/file-first")
+
+        # Follow relation
+        content = await read_note("docs/architecture/depends-on/docs/content-parser")
+
+        # Pattern matching
+        content = await read_note("docs/*-architecture")  # All architecture docs
+        content = await read_note("docs/*/implements/*")  # Find implementations
+
+    Output format:
+        ```
+        --- memory://docs/example 2025-01-31T19:32:49 7d9f1c8b
+        <first document content>
+
+        --- memory://docs/other 2025-01-30T15:45:22 a1b2c3d4
+        <second document content>
+        ```
 
-    Raises:
-        ValueError: If the note cannot be found
+    The headers include:
+    - Full memory:// URI for the document
+    - Last modified timestamp
+    - Content checksum
     """
     logger.info(f"Reading note {identifier}")
     url = memory_url_path(identifier)

src/basic_memory/mcp/tools/utils.py

@@ -151,4 +151,4 @@ async def call_delete(
         return response
     except HTTPStatusError as e:
         logger.error(f"Error calling DELETE {url}: {e}")
-        raise ToolError(f"Error calling tool: {e}") from e
+        raise ToolError(f"Error calling tool: {e}") from e

src/basic_memory/repository/search_repository.py

@@ -73,7 +73,7 @@ async def init_search_index(self):
             async with db.scoped_session(self.session_maker) as session:
                 await session.execute(CREATE_SEARCH_INDEX)
                 await session.commit()
-        except Exception as e:
+        except Exception as e: # pragma: no cover
             logger.error(f"Error initializing search index: {e}")
             raise e
 
@@ -86,31 +86,22 @@ def _prepare_search_term(self, term: str, is_prefix: bool = True) -> str:
             
         For FTS5:
         - Special characters and phrases need to be quoted
-        - Prefix searches (trailing *) need special handling
         - Terms with spaces or special chars need quotes
         """
+        if "*" in term:
+            return term
+        
         # List of special characters that need quoting (excluding *)
         special_chars = ["/", "-", ".", " ", "(", ")", "[", "]", '"', "'"]
-        
-        # Handle trailing wildcard
-        has_trailing_wildcard = term.endswith('*')
-        if has_trailing_wildcard:
-            term = term[:-1]  # Remove trailing * for processing
-            
+                    
         # Check if term contains any special characters
         needs_quotes = any(c in term for c in special_chars)
 
         if needs_quotes:
-            # If the term already contains quotes, escape them
+            # If the term already contains quotes, escape them and add a wildcard
             term = term.replace('"', '""')
-            term = f'"{term}"'
-            
-        # Add prefix search capability
-        if is_prefix and not has_trailing_wildcard:
-            term = f"{term}*"
-        elif has_trailing_wildcard:
-            term = f"{term}*"
-            
+            term = f'"{term}"*'
+                        
         return term
 
     async def search(
@@ -131,13 +122,13 @@ async def search(
 
         # Handle text search for title and content
         if search_text:
-            search_text = self._prepare_search_term(search_text.lower().strip())
+            search_text = self._prepare_search_term(search_text.strip())
             params["text"] = search_text
             conditions.append("(title MATCH :text OR content MATCH :text)")
 
         # Handle title match search
         if title:
-            title_text = self._prepare_search_term(title.lower().strip())
+            title_text = self._prepare_search_term(title.strip())
             params["text"] = title_text
             conditions.append("title MATCH :text")
 
@@ -148,10 +139,14 @@ async def search(
 
         # Handle permalink match search, supports *
         if permalink_match:
-            # Clean and prepare permalink for FTS5 pattern match
+            # Clean and prepare permalink for FTS5 GLOB match
             permalink_text = self._prepare_search_term(permalink_match.lower().strip(), is_prefix=False)
             params["permalink"] = permalink_text
-            conditions.append("permalink GLOB :permalink")
+            if "*" in permalink_match:
+                conditions.append("permalink GLOB :permalink")
+            else: 
+                conditions.append("permalink MATCH :permalink")
+
 
         # Handle type filter
         if types:
@@ -200,7 +195,7 @@ async def search(
             LIMIT :limit
         """
 
-        # logger.debug(f"Search {sql} params: {params}")
+        logger.debug(f"Search {sql} params: {params}")
         async with db.scoped_session(self.session_maker) as session:
             result = await session.execute(text(sql), params)
             rows = result.fetchall()
@@ -226,8 +221,9 @@ async def search(
             for row in rows
         ]
 
-        # for r in results:
-        #    logger.debug(f"Search result: type:{r.type} title: {r.title} permalink: {r.permalink} score: {r.score}")
+        logger.debug(f"Found {len(results)} search results")
+        for r in results:
+            logger.debug(f"Search result: type:{r.type} title: {r.title} permalink: {r.permalink} score: {r.score}")
 
         return results
 
@@ -260,7 +256,7 @@ async def index_item(
                 """),
                 search_index_row.to_insert(),
             )
-            logger.debug(f"indexed permalink {search_index_row.permalink}")
+            logger.debug(f"indexed row {search_index_row}")
             await session.commit()
 
     async def delete_by_permalink(self, permalink: str):