basic-memory 0.14.2__py3-none-any.whl → 0.14.4__py3-none-any.whl

basic_memory/schemas/base.py

@@ -22,6 +22,8 @@ from dateparser import parse
 
 from pydantic import BaseModel, BeforeValidator, Field, model_validator
 
+from basic_memory.config import ConfigManager
+from basic_memory.file_utils import sanitize_for_filename
 from basic_memory.utils import generate_permalink
 
 
@@ -53,22 +55,28 @@ def parse_timeframe(timeframe: str) -> datetime:
         timeframe: Natural language timeframe like 'today', '1d', '1 week ago', etc.
 
     Returns:
-        datetime: The parsed datetime for the start of the timeframe
+        datetime: The parsed datetime for the start of the timeframe, timezone-aware in local system timezone
 
     Examples:
-        parse_timeframe('today') -> 2025-06-05 00:00:00 (start of today)
-        parse_timeframe('1d') -> 2025-06-04 14:50:00 (24 hours ago)
-        parse_timeframe('1 week ago') -> 2025-05-29 14:50:00 (1 week ago)
+        parse_timeframe('today') -> 2025-06-05 00:00:00-07:00 (start of today with local timezone)
+        parse_timeframe('1d') -> 2025-06-04 14:50:00-07:00 (24 hours ago with local timezone)
+        parse_timeframe('1 week ago') -> 2025-05-29 14:50:00-07:00 (1 week ago with local timezone)
     """
     if timeframe.lower() == "today":
-        # Return start of today (00:00:00)
-        return datetime.combine(datetime.now().date(), time.min)
+        # Return start of today (00:00:00) in local timezone
+        naive_dt = datetime.combine(datetime.now().date(), time.min)
+        return naive_dt.astimezone()
     else:
         # Use dateparser for other formats
         parsed = parse(timeframe)
         if not parsed:
             raise ValueError(f"Could not parse timeframe: {timeframe}")
-        return parsed
+        
+        # If the parsed datetime is naive, make it timezone-aware in local system timezone
+        if parsed.tzinfo is None:
+            return parsed.astimezone()
+        else:
+            return parsed
 
 
 def validate_timeframe(timeframe: str) -> str:
@@ -85,7 +93,7 @@ def validate_timeframe(timeframe: str) -> str:
     parsed = parse_timeframe(timeframe)
 
     # Convert to duration
-    now = datetime.now()
+    now = datetime.now().astimezone()
     if parsed > now:
         raise ValueError("Timeframe cannot be in the future")
 
@@ -184,13 +192,35 @@ class Entity(BaseModel):
         default="text/markdown",
     )
 
+    @property
+    def safe_title(self) -> str:
+        """
+        A sanitized version of the title, which is safe for use on the filesystem. For example,
+        a title of "Coupon Enable/Disable Feature" should create a the file as "Coupon Enable-Disable Feature.md"
+        instead of creating a file named "Disable Feature.md" beneath the "Coupon Enable" directory.
+
+        Replaces POSIX and/or Windows style slashes as well as a few other characters that are not safe for filenames.
+        If kebab_filenames is True, then behavior is consistent with transformation used when generating permalink
+        strings (e.g. "Coupon Enable/Disable Feature" -> "coupon-enable-disable-feature").
+        """
+        fixed_title = sanitize_for_filename(self.title)
+
+        app_config = ConfigManager().config
+        use_kebab_case = app_config.kebab_filenames
+
+        if use_kebab_case:
+            fixed_title = generate_permalink(file_path=fixed_title, split_extension=False)
+
+        return fixed_title
+
     @property
     def file_path(self):
         """Get the file path for this entity based on its permalink."""
+        safe_title = self.safe_title
         if self.content_type == "text/markdown":
-            return f"{self.folder}/{self.title}.md" if self.folder else f"{self.title}.md"
+            return f"{self.folder}/{safe_title}.md" if self.folder else f"{safe_title}.md"
         else:
-            return f"{self.folder}/{self.title}" if self.folder else self.title
+            return f"{self.folder}/{safe_title}" if self.folder else safe_title
 
     @property
     def permalink(self) -> Permalink:

basic_memory/schemas/importer.py

@@ -32,3 +32,4 @@ class EntityImportResult(ImportResult):
 
     entities: int = 0
     relations: int = 0
+    skipped_entities: int = 0

basic_memory/schemas/memory.py

@@ -1,10 +1,10 @@
 """Schemas for memory context."""
 
 from datetime import datetime
-from typing import List, Optional, Annotated, Sequence
+from typing import List, Optional, Annotated, Sequence, Literal, Union
 
 from annotated_types import MinLen, MaxLen
-from pydantic import BaseModel, Field, BeforeValidator, TypeAdapter
+from pydantic import BaseModel, Field, BeforeValidator, TypeAdapter, ConfigDict
 
 from basic_memory.schemas.search import SearchItemType
 
@@ -117,8 +117,10 @@ def memory_url_path(url: memory_url) -> str:  # pyright: ignore
 
 class EntitySummary(BaseModel):
     """Simplified entity representation."""
+    
+    model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
 
-    type: str = "entity"
+    type: Literal["entity"] = "entity"
     permalink: Optional[str]
     title: str
     content: Optional[str] = None
@@ -128,8 +130,10 @@ class EntitySummary(BaseModel):
 
 class RelationSummary(BaseModel):
     """Simplified relation representation."""
+    
+    model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
 
-    type: str = "relation"
+    type: Literal["relation"] = "relation"
     title: str
     file_path: str
     permalink: str
@@ -141,8 +145,10 @@ class RelationSummary(BaseModel):
 
 class ObservationSummary(BaseModel):
     """Simplified observation representation."""
+    
+    model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
 
-    type: str = "observation"
+    type: Literal["observation"] = "observation"
     title: str
     file_path: str
     permalink: str
@@ -153,6 +159,8 @@ class ObservationSummary(BaseModel):
 
 class MemoryMetadata(BaseModel):
     """Simplified response metadata."""
+    
+    model_config = ConfigDict(json_encoders={datetime: lambda dt: dt.isoformat()})
 
     uri: Optional[str] = None
     types: Optional[List[SearchItemType]] = None
@@ -169,17 +177,21 @@ class MemoryMetadata(BaseModel):
 class ContextResult(BaseModel):
     """Context result containing a primary item with its observations and related items."""
 
-    primary_result: EntitySummary | RelationSummary | ObservationSummary = Field(
-        description="Primary item"
-    )
+    primary_result: Annotated[
+        Union[EntitySummary, RelationSummary, ObservationSummary], 
+        Field(discriminator="type", description="Primary item")
+    ]
 
     observations: Sequence[ObservationSummary] = Field(
         description="Observations belonging to this entity", default_factory=list
     )
 
-    related_results: Sequence[EntitySummary | RelationSummary | ObservationSummary] = Field(
-        description="Related items", default_factory=list
-    )
+    related_results: Sequence[
+        Annotated[
+            Union[EntitySummary, RelationSummary, ObservationSummary], 
+            Field(discriminator="type")
+        ]
+    ] = Field(description="Related items", default_factory=list)
 
 
 class GraphContext(BaseModel):

basic_memory/services/context_service.py

@@ -245,8 +245,8 @@ class ContextService:
         # For compatibility with the old query, we still need this for filtering
         values = ", ".join([f"('{t}', {i})" for t, i in type_id_pairs])
 
-        # Parameters for bindings
-        params = {"max_depth": max_depth, "max_results": max_results}
+        # Parameters for bindings - include project_id for security filtering
+        params = {"max_depth": max_depth, "max_results": max_results, "project_id": self.search_repository.project_id}
 
         # Build date and timeframe filters conditionally based on since parameter
         if since:
@@ -258,6 +258,10 @@ class ContextService:
             date_filter = ""
             relation_date_filter = ""
             timeframe_condition = ""
+        
+        # Add project filtering for security - ensure all entities and relations belong to the same project
+        project_filter = "AND e.project_id = :project_id"
+        relation_project_filter = "AND e_from.project_id = :project_id"
 
         # Use a CTE that operates directly on entity and relation tables
         # This avoids the overhead of the search_index virtual table
@@ -284,6 +288,7 @@ class ContextService:
             FROM entity e
             WHERE e.id IN ({entity_id_values})
             {date_filter}
+            {project_filter}
 
             UNION ALL
 
@@ -314,8 +319,12 @@ class ContextService:
             JOIN entity e_from ON (
                 r.from_id = e_from.id
                 {relation_date_filter}
+                {relation_project_filter}
             )
+            LEFT JOIN entity e_to ON (r.to_id = e_to.id)
             WHERE eg.depth < :max_depth
+            -- Ensure to_entity (if exists) also belongs to same project
+            AND (r.to_id IS NULL OR e_to.project_id = :project_id)
 
             UNION ALL
 
@@ -348,6 +357,7 @@ class ContextService:
                     ELSE eg.from_id
                 END
                 {date_filter}
+                {project_filter}
             )
             WHERE eg.depth < :max_depth
             -- Only include entities connected by relations within timeframe if specified

basic_memory/services/directory_service.py

@@ -106,8 +106,15 @@ class DirectoryService:
             List of DirectoryNode objects matching the criteria
         """
         # Normalize directory path
+        # Strip ./ prefix if present (handles relative path notation)
+        if dir_name.startswith("./"):
+            dir_name = dir_name[2:]  # Remove "./" prefix
+
+        # Ensure path starts with "/"
         if not dir_name.startswith("/"):
             dir_name = f"/{dir_name}"
+
+        # Remove trailing slashes except for root
         if dir_name != "/" and dir_name.endswith("/"):
             dir_name = dir_name.rstrip("/")
 

basic_memory/services/entity_service.py

@@ -9,12 +9,13 @@ from loguru import logger
 from sqlalchemy.exc import IntegrityError
 
 from basic_memory.config import ProjectConfig, BasicMemoryConfig
-from basic_memory.file_utils import has_frontmatter, parse_frontmatter, remove_frontmatter
+from basic_memory.file_utils import has_frontmatter, parse_frontmatter, remove_frontmatter, dump_frontmatter
 from basic_memory.markdown import EntityMarkdown
 from basic_memory.markdown.entity_parser import EntityParser
 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
+from basic_memory.models.knowledge import Entity
 from basic_memory.repository import ObservationRepository, RelationRepository
 from basic_memory.repository.entity_repository import EntityRepository
 from basic_memory.schemas import Entity as EntitySchema
@@ -44,6 +45,39 @@ class EntityService(BaseService[EntityModel]):
         self.file_service = file_service
         self.link_resolver = link_resolver
 
+    async def detect_file_path_conflicts(self, file_path: str) -> List[Entity]:
+        """Detect potential file path conflicts for a given file path.
+
+        This checks for entities with similar file paths that might cause conflicts:
+        - Case sensitivity differences (Finance/file.md vs finance/file.md)
+        - Character encoding differences
+        - Hyphen vs space differences
+        - Unicode normalization differences
+
+        Args:
+            file_path: The file path to check for conflicts
+
+        Returns:
+            List of entities that might conflict with the given file path
+        """
+        from basic_memory.utils import detect_potential_file_conflicts
+
+        conflicts = []
+
+        # Get all existing file paths
+        all_entities = await self.repository.find_all()
+        existing_paths = [entity.file_path for entity in all_entities]
+
+        # Use the enhanced conflict detection utility
+        conflicting_paths = detect_potential_file_conflicts(file_path, existing_paths)
+
+        # Find the entities corresponding to conflicting paths
+        for entity in all_entities:
+            if entity.file_path in conflicting_paths:
+                conflicts.append(entity)
+
+        return conflicts
+
     async def resolve_permalink(
         self, file_path: Permalink | Path, markdown: Optional[EntityMarkdown] = None
     ) -> str:
@@ -54,18 +88,30 @@ class EntityService(BaseService[EntityModel]):
         2. If markdown has permalink but it's used by another file -> make unique
         3. For existing files, keep current permalink from db
         4. Generate new unique permalink from file path
+
+        Enhanced to detect and handle character-related conflicts.
         """
+        file_path_str = Path(file_path).as_posix()
+
+        # Check for potential file path conflicts before resolving permalink
+        conflicts = await self.detect_file_path_conflicts(file_path_str)
+        if conflicts:
+            logger.warning(
+                f"Detected potential file path conflicts for '{file_path_str}': "
+                f"{[entity.file_path for entity in conflicts]}"
+            )
+
         # If markdown has explicit permalink, try to validate it
         if markdown and markdown.frontmatter.permalink:
             desired_permalink = markdown.frontmatter.permalink
             existing = await self.repository.get_by_permalink(desired_permalink)
 
             # If no conflict or it's our own file, use as is
-            if not existing or existing.file_path == str(file_path):
+            if not existing or existing.file_path == file_path_str:
                 return desired_permalink
 
         # For existing files, try to find current permalink
-        existing = await self.repository.get_by_file_path(str(file_path))
+        existing = await self.repository.get_by_file_path(file_path_str)
         if existing:
             return existing.permalink
 
@@ -73,9 +119,9 @@ class EntityService(BaseService[EntityModel]):
         if markdown and markdown.frontmatter.permalink:
             desired_permalink = markdown.frontmatter.permalink
         else:
-            desired_permalink = generate_permalink(file_path)
+            desired_permalink = generate_permalink(file_path_str)
 
-        # Make unique if needed
+        # Make unique if needed - enhanced to handle character conflicts
         permalink = desired_permalink
         suffix = 1
         while await self.repository.get_by_permalink(permalink):
@@ -150,7 +196,7 @@ class EntityService(BaseService[EntityModel]):
         post = await schema_to_markdown(schema)
 
         # write file
-        final_content = frontmatter.dumps(post, sort_keys=False)
+        final_content = dump_frontmatter(post)
         checksum = await self.file_service.write_file(file_path, final_content)
 
         # parse entity from file
@@ -227,7 +273,7 @@ class EntityService(BaseService[EntityModel]):
         merged_post = frontmatter.Post(post.content, **existing_markdown.frontmatter.metadata)
 
         # write file
-        final_content = frontmatter.dumps(merged_post, sort_keys=False)
+        final_content = dump_frontmatter(merged_post)
         checksum = await self.file_service.write_file(file_path, final_content)
 
         # parse entity from file
@@ -237,7 +283,7 @@ class EntityService(BaseService[EntityModel]):
         entity = await self.update_entity_and_observations(file_path, entity_markdown)
 
         # add relations
-        await self.update_entity_relations(str(file_path), entity_markdown)
+        await self.update_entity_relations(file_path.as_posix(), entity_markdown)
 
         # Set final checksum to match file
         entity = await self.repository.update(entity.id, {"checksum": checksum})
@@ -328,7 +374,7 @@ class EntityService(BaseService[EntityModel]):
         """
         logger.debug(f"Updating entity and observations: {file_path}")
 
-        db_entity = await self.repository.get_by_file_path(str(file_path))
+        db_entity = await self.repository.get_by_file_path(file_path.as_posix())
 
         # Clear observations for entity
         await self.observation_repository.delete_by_fields(entity_id=db_entity.id)
@@ -452,7 +498,7 @@ class EntityService(BaseService[EntityModel]):
 
         # Update entity and its relationships
         entity = await self.update_entity_and_observations(file_path, entity_markdown)
-        await self.update_entity_relations(str(file_path), entity_markdown)
+        await self.update_entity_relations(file_path.as_posix(), entity_markdown)
 
         # Set final checksum to match file
         entity = await self.repository.update(entity.id, {"checksum": checksum})

basic_memory/services/initialization.py

@@ -5,14 +5,12 @@ to ensure consistent application startup across all entry points.
 """
 
 import asyncio
-import shutil
 from pathlib import Path
 
 from loguru import logger
 
 from basic_memory import db
 from basic_memory.config import BasicMemoryConfig
-from basic_memory.models import Project
 from basic_memory.repository import ProjectRepository
 
 
@@ -70,63 +68,6 @@ async def reconcile_projects_with_config(app_config: BasicMemoryConfig):
         logger.info("Continuing with initialization despite synchronization error")
 
 
-async def migrate_legacy_projects(app_config: BasicMemoryConfig):
-    # Get database session - migrations handled centrally
-    _, session_maker = await db.get_or_create_db(
-        db_path=app_config.database_path,
-        db_type=db.DatabaseType.FILESYSTEM,
-        ensure_migrations=False,
-    )
-    logger.info("Migrating legacy projects...")
-    project_repository = ProjectRepository(session_maker)
-
-    # For each project in config.json, check if it has a .basic-memory dir
-    for project_name, project_path in app_config.projects.items():
-        legacy_dir = Path(project_path) / ".basic-memory"
-        if not legacy_dir.exists():
-            continue
-        logger.info(f"Detected legacy project directory: {legacy_dir}")
-        project = await project_repository.get_by_name(project_name)
-        if not project:  # pragma: no cover
-            logger.error(f"Project {project_name} not found in database, skipping migration")
-            continue
-
-        logger.info(f"Starting migration for project: {project_name} (id: {project.id})")
-        await migrate_legacy_project_data(project, legacy_dir)
-        logger.info(f"Completed migration for project: {project_name}")
-    logger.info("Legacy projects successfully migrated")
-
-
-async def migrate_legacy_project_data(project: Project, legacy_dir: Path) -> bool:
-    """Check if project has legacy .basic-memory dir and migrate if needed.
-
-    Args:
-        project: The project to check and potentially migrate
-
-    Returns:
-        True if migration occurred, False otherwise
-    """
-
-    # avoid circular imports
-    from basic_memory.cli.commands.sync import get_sync_service
-
-    sync_service = await get_sync_service(project)
-    sync_dir = Path(project.path)
-
-    logger.info(f"Sync starting project: {project.name}")
-    await sync_service.sync(sync_dir, project_name=project.name)
-    logger.info(f"Sync completed successfully for project: {project.name}")
-
-    # After successful sync, remove the legacy directory
-    try:
-        logger.info(f"Removing legacy directory: {legacy_dir}")
-        shutil.rmtree(legacy_dir)
-        return True
-    except Exception as e:
-        logger.error(f"Error removing legacy directory: {e}")
-        return False
-
-
 async def initialize_file_sync(
     app_config: BasicMemoryConfig,
 ):
@@ -186,16 +127,6 @@ async def initialize_file_sync(
             sync_status_tracker.fail_project_sync(project.name, str(e))
             # Continue with other projects even if one fails
 
-    # Mark migration complete if it was in progress
-    try:
-        from basic_memory.services.migration_service import migration_manager
-
-        if not migration_manager.is_ready:  # pragma: no cover
-            migration_manager.mark_completed("Migration completed with file sync")
-            logger.info("Marked migration as completed after file sync")
-    except Exception as e:  # pragma: no cover
-        logger.warning(f"Could not update migration status: {e}")
-
     # Then start the watch service in the background
     logger.info("Starting watch service for all projects")
     # run the watch service
@@ -229,13 +160,7 @@ async def initialize_app(
     # Reconcile projects from config.json with projects table
     await reconcile_projects_with_config(app_config)
 
-    # Start background migration for legacy project data (non-blocking)
-    from basic_memory.services.migration_service import migration_manager
-
-    await migration_manager.start_background_migration(app_config)
-
     logger.info("App initialization completed (migration running in background if needed)")
-    return migration_manager
 
 
 def ensure_initialization(app_config: BasicMemoryConfig) -> None: