basic-memory 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

basic_memory/schemas/memory.py

@@ -9,7 +9,7 @@ from pydantic import BaseModel, Field, BeforeValidator, TypeAdapter
 from basic_memory.schemas.search import SearchItemType
 
 
-def normalize_memory_url(url: str) -> str:
+def normalize_memory_url(url: str | None) -> str:
     """Normalize a MemoryUrl string.
 
     Args:
@@ -24,6 +24,9 @@ def normalize_memory_url(url: str) -> str:
         >>> normalize_memory_url("memory://specs/search")
         'memory://specs/search'
     """
+    if not url:
+        return ""
+
     clean_path = url.removeprefix("memory://")
     return f"memory://{clean_path}"
 
@@ -59,7 +62,7 @@ class EntitySummary(BaseModel):
     """Simplified entity representation."""
 
     type: str = "entity"
-    permalink: str
+    permalink: Optional[str]
     title: str
     file_path: str
     created_at: datetime
@@ -69,19 +72,25 @@ class RelationSummary(BaseModel):
     """Simplified relation representation."""
 
     type: str = "relation"
+    title: str
+    file_path: str
     permalink: str
     relation_type: str
     from_id: str
     to_id: Optional[str] = None
+    created_at: datetime
 
 
 class ObservationSummary(BaseModel):
     """Simplified observation representation."""
 
     type: str = "observation"
+    title: str
+    file_path: str
     permalink: str
     category: str
     content: str
+    created_at: datetime
 
 
 class MemoryMetadata(BaseModel):

basic_memory/schemas/search.py

@@ -68,9 +68,10 @@ class SearchResult(BaseModel):
     """Search result with score and metadata."""
 
     id: int
+    title: str
     type: SearchItemType
     score: float
-    permalink: str
+    permalink: Optional[str]
     file_path: str
 
     metadata: Optional[dict] = None

basic_memory/services/entity_service.py

@@ -124,17 +124,19 @@ class EntityService(BaseService[EntityModel]):
         entity_markdown = await self.entity_parser.parse_file(file_path)
 
         # create entity
-        await self.create_entity_from_markdown(file_path, entity_markdown)
+        created = await self.create_entity_from_markdown(file_path, entity_markdown)
 
         # add relations
-        entity = await self.update_entity_relations(file_path, entity_markdown)
+        entity = await self.update_entity_relations(created.file_path, entity_markdown)
 
         # Set final checksum to mark complete
         return await self.repository.update(entity.id, {"checksum": checksum})
 
     async def update_entity(self, entity: EntityModel, schema: EntitySchema) -> EntityModel:
         """Update an entity's content and metadata."""
-        logger.debug(f"Updating entity with permalink: {entity.permalink}")
+        logger.debug(
+            f"Updating entity with permalink: {entity.permalink} content-type: {schema.content_type}"
+        )
 
         # Convert file path string to Path
         file_path = Path(entity.file_path)
@@ -152,20 +154,25 @@ class EntityService(BaseService[EntityModel]):
         entity = await self.update_entity_and_observations(file_path, entity_markdown)
 
         # add relations
-        await self.update_entity_relations(file_path, entity_markdown)
+        await self.update_entity_relations(str(file_path), entity_markdown)
 
         # Set final checksum to match file
         entity = await self.repository.update(entity.id, {"checksum": checksum})
 
         return entity
 
-    async def delete_entity(self, permalink: str) -> bool:
+    async def delete_entity(self, permalink_or_id: str | int) -> bool:
         """Delete entity and its file."""
-        logger.debug(f"Deleting entity: {permalink}")
+        logger.debug(f"Deleting entity: {permalink_or_id}")
 
         try:
             # Get entity first for file deletion
-            entity = await self.get_by_permalink(permalink)
+            if isinstance(permalink_or_id, str):
+                entity = await self.get_by_permalink(permalink_or_id)
+            else:
+                entities = await self.get_entities_by_id([permalink_or_id])
+                assert len(entities) == 1, f"Expected 1 entity, got {len(entities)}"
+                entity = entities[0]
 
             # Delete file first
             await self.file_service.delete_entity_file(entity)
@@ -174,7 +181,7 @@ class EntityService(BaseService[EntityModel]):
             return await self.repository.delete(entity.id)
 
         except EntityNotFoundError:
-            logger.info(f"Entity not found: {permalink}")
+            logger.info(f"Entity not found: {permalink_or_id}")
             return True  # Already deleted
 
     async def get_by_permalink(self, permalink: str) -> EntityModel:
@@ -256,13 +263,13 @@ class EntityService(BaseService[EntityModel]):
 
     async def update_entity_relations(
         self,
-        file_path: Path,
+        path: str,
         markdown: EntityMarkdown,
     ) -> EntityModel:
         """Update relations for entity"""
-        logger.debug(f"Updating relations for entity: {file_path}")
+        logger.debug(f"Updating relations for entity: {path}")
 
-        db_entity = await self.repository.get_by_file_path(str(file_path))
+        db_entity = await self.repository.get_by_file_path(path)
 
         # Clear existing relations first
         await self.relation_repository.delete_outgoing_relations_from_entity(db_entity.id)
@@ -296,4 +303,4 @@ class EntityService(BaseService[EntityModel]):
                 )
                 continue
 
-        return await self.repository.get_by_file_path(str(file_path))
+        return await self.repository.get_by_file_path(path)

basic_memory/services/file_service.py

@@ -1,11 +1,14 @@
 """Service for file operations with checksum tracking."""
 
+import mimetypes
+from os import stat_result
 from pathlib import Path
-from typing import Tuple, Union
+from typing import Tuple, Union, Dict, Any
 
 from loguru import logger
 
 from basic_memory import file_utils
+from basic_memory.file_utils import FileError
 from basic_memory.markdown.markdown_processor import MarkdownProcessor
 from basic_memory.models import Entity as EntityModel
 from basic_memory.schemas import Entity as EntitySchema
@@ -134,6 +137,7 @@ class FileService:
             logger.error(f"Failed to write file {full_path}: {e}")
             raise FileOperationError(f"Failed to write file: {e}")
 
+    # TODO remove read_file
     async def read_file(self, path: Union[Path, str]) -> Tuple[str, str]:
         """Read file and compute checksum.
 
@@ -153,7 +157,7 @@ class FileService:
         full_path = path if path.is_absolute() else self.base_path / path
 
         try:
-            content = path.read_text()
+            content = full_path.read_text()
             checksum = await file_utils.compute_checksum(content)
             logger.debug(f"read file: {full_path}, checksum: {checksum}")
             return content, checksum
@@ -174,3 +178,66 @@ class FileService:
         path = Path(path)
         full_path = path if path.is_absolute() else self.base_path / path
         full_path.unlink(missing_ok=True)
+
+    async def update_frontmatter(self, path: Union[Path, str], updates: Dict[str, Any]) -> str:
+        """
+        Update frontmatter fields in a file while preserving all content.
+        """
+
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+        return await file_utils.update_frontmatter(full_path, updates)
+
+    async def compute_checksum(self, path: Union[str, Path]) -> str:
+        """Compute checksum for a file."""
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+        try:
+            if self.is_markdown(path):
+                # read str
+                content = full_path.read_text()
+            else:
+                # read bytes
+                content = full_path.read_bytes()
+            return await file_utils.compute_checksum(content)
+
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Failed to compute checksum for {path}: {e}")
+            raise FileError(f"Failed to compute checksum for {path}: {e}")
+
+    def file_stats(self, path: Union[Path, str]) -> stat_result:
+        """
+        Return file stats for a given path.
+        :param path:
+        :return:
+        """
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+        # get file timestamps
+        return full_path.stat()
+
+    def content_type(self, path: Union[Path, str]) -> str:
+        """
+        Return content_type for a given path.
+        :param path:
+        :return:
+        """
+        path = Path(path)
+        full_path = path if path.is_absolute() else self.base_path / path
+        # get file timestamps
+        mime_type, _ = mimetypes.guess_type(full_path.name)
+
+        # .canvas files are json
+        if full_path.suffix == ".canvas":
+            mime_type = "application/json"
+
+        content_type = mime_type or "text/plain"
+        return content_type
+
+    def is_markdown(self, path: Union[Path, str]) -> bool:
+        """
+        Return content_type for a given path.
+        :param path:
+        :return:
+        """
+        return self.content_type(path) == "text/markdown"

basic_memory/services/link_resolver.py

@@ -4,11 +4,11 @@ from typing import Optional, Tuple, List
 
 from loguru import logger
 
+from basic_memory.models import Entity
 from basic_memory.repository.entity_repository import EntityRepository
 from basic_memory.repository.search_repository import SearchIndexRow
-from basic_memory.services.search_service import SearchService
-from basic_memory.models import Entity
 from basic_memory.schemas.search import SearchQuery, SearchItemType
+from basic_memory.services.search_service import SearchService
 
 
 class LinkResolver:
@@ -58,7 +58,8 @@ class LinkResolver:
                 logger.debug(
                     f"Selected best match from {len(results)} results: {best_match.permalink}"
                 )
-                return await self.entity_repository.get_by_permalink(best_match.permalink)
+                if best_match.permalink:
+                    return await self.entity_repository.get_by_permalink(best_match.permalink)
 
         # if we couldn't find anything then return None
         return None
@@ -103,12 +104,14 @@ class LinkResolver:
         scored_results = []
         for result in results:
             # Start with base score (lower is better)
-            score = result.score
-            assert score is not None
-
-            # Parse path components
-            path_parts = result.permalink.lower().split("/")
-            last_part = path_parts[-1] if path_parts else ""
+            score = result.score or 0
+
+            if result.permalink:
+                # Parse path components
+                path_parts = result.permalink.lower().split("/")
+                last_part = path_parts[-1] if path_parts else ""
+            else:
+                last_part = ""  # pragma: no cover
 
             # Title word match boosts
             term_matches = [term for term in terms if term in last_part]

basic_memory/services/search_service.py

@@ -3,6 +3,7 @@
 from datetime import datetime
 from typing import List, Optional, Set
 
+from dateparser import parse
 from fastapi import BackgroundTasks
 from loguru import logger
 
@@ -69,7 +70,7 @@ class SearchService:
             (
                 query.after_date
                 if isinstance(query.after_date, datetime)
-                else datetime.fromisoformat(query.after_date)
+                else parse(query.after_date)
             )
             if query.after_date
             else None
@@ -118,6 +119,46 @@ class SearchService:
         self,
         entity: Entity,
         background_tasks: Optional[BackgroundTasks] = None,
+    ) -> None:
+        if background_tasks:
+            background_tasks.add_task(self.index_entity_data, entity)
+        else:
+            await self.index_entity_data(entity)
+
+    async def index_entity_data(
+        self,
+        entity: Entity,
+    ) -> None:
+        # delete all search index data associated with entity
+        await self.repository.delete_by_entity_id(entity_id=entity.id)
+
+        # reindex
+        await self.index_entity_markdown(
+            entity
+        ) if entity.is_markdown else await self.index_entity_file(entity)
+
+    async def index_entity_file(
+        self,
+        entity: Entity,
+    ) -> None:
+        # Index entity file with no content
+        await self.repository.index_item(
+            SearchIndexRow(
+                id=entity.id,
+                type=SearchItemType.ENTITY.value,
+                title=entity.title,
+                file_path=entity.file_path,
+                metadata={
+                    "entity_type": entity.entity_type,
+                },
+                created_at=entity.created_at,
+                updated_at=entity.updated_at,
+            )
+        )
+
+    async def index_entity_markdown(
+        self,
+        entity: Entity,
     ) -> None:
         """Index an entity and all its observations and relations.
 
@@ -136,16 +177,10 @@ class SearchService:
 
         Each type gets its own row in the search index with appropriate metadata.
         """
-        if background_tasks:
-            background_tasks.add_task(self.index_entity_data, entity)
-        else:
-            await self.index_entity_data(entity)
 
-    async def index_entity_data(
-        self,
-        entity: Entity,
-    ) -> None:
-        """Actually perform the indexing."""
+        assert entity.permalink is not None, (
+            "entity.permalink should not be None for markdown entities"
+        )
 
         content_parts = []
         title_variants = self._generate_variants(entity.title)
@@ -160,6 +195,9 @@ class SearchService:
 
         entity_content = "\n".join(p for p in content_parts if p and p.strip())
 
+        assert entity.permalink is not None, (
+            "entity.permalink should not be None for markdown entities"
+        )
         # Index entity
         await self.repository.index_item(
             SearchIndexRow(
@@ -169,6 +207,7 @@ class SearchService:
                 content=entity_content,
                 permalink=entity.permalink,
                 file_path=entity.file_path,
+                entity_id=entity.id,
                 metadata={
                     "entity_type": entity.entity_type,
                 },
@@ -214,6 +253,7 @@ class SearchService:
                     permalink=rel.permalink,
                     file_path=entity.file_path,
                     type=SearchItemType.RELATION.value,
+                    entity_id=entity.id,
                     from_id=rel.from_id,
                     to_id=rel.to_id,
                     relation_type=rel.relation_type,
@@ -222,6 +262,10 @@ class SearchService:
                 )
             )
 
-    async def delete_by_permalink(self, path_id: str):
+    async def delete_by_permalink(self, permalink: str):
+        """Delete an item from the search index."""
+        await self.repository.delete_by_permalink(permalink)
+
+    async def delete_by_entity_id(self, entity_id: int):
         """Delete an item from the search index."""
-        await self.repository.delete_by_permalink(path_id)
+        await self.repository.delete_by_entity_id(entity_id)

basic_memory/sync/__init__.py

@@ -1,5 +1,6 @@
-from .file_change_scanner import FileChangeScanner
+"""Basic Memory sync services."""
+
 from .sync_service import SyncService
 from .watch_service import WatchService
 
-__all__ = ["SyncService", "FileChangeScanner", "WatchService"]
+__all__ = ["SyncService", "WatchService"]