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

basic_memory/services/project_service.py

@@ -9,7 +9,6 @@ from typing import Dict, Optional, Sequence
 from loguru import logger
 from sqlalchemy import text
 
-from basic_memory.config import config, app_config
 from basic_memory.models import Project
 from basic_memory.repository.project_repository import ProjectRepository
 from basic_memory.schemas import (
@@ -18,9 +17,8 @@ from basic_memory.schemas import (
     ProjectStatistics,
     SystemStatus,
 )
-from basic_memory.config import WATCH_STATUS_JSON
+from basic_memory.config import WATCH_STATUS_JSON, ConfigManager, get_project_config, ProjectConfig
 from basic_memory.utils import generate_permalink
-from basic_memory.config import config_manager
 
 
 class ProjectService:
@@ -33,6 +31,24 @@ class ProjectService:
         super().__init__()
         self.repository = repository
 
+    @property
+    def config_manager(self) -> ConfigManager:
+        """Get a ConfigManager instance.
+
+        Returns:
+            Fresh ConfigManager instance for each access
+        """
+        return ConfigManager()
+
+    @property
+    def config(self) -> ProjectConfig:
+        """Get the current project configuration.
+
+        Returns:
+            Current project configuration
+        """
+        return get_project_config()
+
     @property
     def projects(self) -> Dict[str, str]:
         """Get all configured projects.
@@ -40,7 +56,7 @@ class ProjectService:
         Returns:
             Dict mapping project names to their file paths
         """
-        return config_manager.projects
+        return self.config_manager.projects
 
     @property
     def default_project(self) -> str:
@@ -49,7 +65,7 @@ class ProjectService:
         Returns:
             The name of the default project
         """
-        return config_manager.default_project
+        return self.config_manager.default_project
 
     @property
     def current_project(self) -> str:
@@ -58,7 +74,7 @@ class ProjectService:
         Returns:
             The name of the current project
         """
-        return os.environ.get("BASIC_MEMORY_PROJECT", config_manager.default_project)
+        return os.environ.get("BASIC_MEMORY_PROJECT", self.config_manager.default_project)
 
     async def list_projects(self) -> Sequence[Project]:
         return await self.repository.find_all()
@@ -84,10 +100,10 @@ class ProjectService:
             raise ValueError("Repository is required for add_project")
 
         # Resolve to absolute path
-        resolved_path = os.path.abspath(os.path.expanduser(path))
+        resolved_path = Path(os.path.abspath(os.path.expanduser(path))).as_posix()
 
         # First add to config file (this will validate the project doesn't exist)
-        project_config = config_manager.add_project(name, resolved_path)
+        project_config = self.config_manager.add_project(name, resolved_path)
 
         # Then add to database
         project_data = {
@@ -103,7 +119,7 @@ class ProjectService:
         # If this should be the default project, ensure only one default exists
         if set_default:
             await self.repository.set_as_default(created_project.id)
-            config_manager.set_default_project(name)
+            self.config_manager.set_default_project(name)
             logger.info(f"Project '{name}' set as default")
 
         logger.info(f"Project '{name}' added at {resolved_path}")
@@ -121,10 +137,10 @@ class ProjectService:
             raise ValueError("Repository is required for remove_project")
 
         # First remove from config (this will validate the project exists and is not default)
-        config_manager.remove_project(name)
+        self.config_manager.remove_project(name)
 
-        # Then remove from database
-        project = await self.repository.get_by_name(name)
+        # Then remove from database using robust lookup
+        project = await self.get_project(name)
         if project:
             await self.repository.delete(project.id)
 
@@ -143,10 +159,10 @@ class ProjectService:
             raise ValueError("Repository is required for set_default_project")
 
         # First update config file (this will validate the project exists)
-        config_manager.set_default_project(name)
+        self.config_manager.set_default_project(name)
 
-        # Then update database
-        project = await self.repository.get_by_name(name)
+        # Then update database using the same lookup logic as get_project
+        project = await self.get_project(name)
         if project:
             await self.repository.set_as_default(project.id)
         else:
@@ -196,7 +212,7 @@ class ProjectService:
         elif len(default_projects) == 0:  # pragma: no cover
             # No default project - set the config default as default
             # This is defensive code for edge cases where no default exists
-            config_default = config_manager.default_project  # pragma: no cover
+            config_default = self.config_manager.default_project  # pragma: no cover
             config_project = await self.repository.get_by_name(config_default)  # pragma: no cover
             if config_project:  # pragma: no cover
                 await self.repository.set_as_default(config_project.id)  # pragma: no cover
@@ -221,7 +237,7 @@ class ProjectService:
         db_projects_by_permalink = {p.permalink: p for p in db_projects}
 
         # Get all projects from configuration and normalize names if needed
-        config_projects = config_manager.projects.copy()
+        config_projects = self.config_manager.projects.copy()
         updated_config = {}
         config_updated = False
 
@@ -237,8 +253,9 @@ class ProjectService:
 
         # Update the configuration if any changes were made
         if config_updated:
-            config_manager.config.projects = updated_config
-            config_manager.save_config(config_manager.config)
+            config = self.config_manager.load_config()
+            config.projects = updated_config
+            self.config_manager.save_config(config)
             logger.info("Config updated with normalized project names")
 
         # Use the normalized config for further processing
@@ -261,19 +278,19 @@ class ProjectService:
         for name, project in db_projects_by_permalink.items():
             if name not in config_projects:
                 logger.info(f"Adding project '{name}' to configuration")
-                config_manager.add_project(name, project.path)
+                self.config_manager.add_project(name, project.path)
 
         # Ensure database default project state is consistent
         await self._ensure_single_default_project()
 
         # Make sure default project is synchronized between config and database
         db_default = await self.repository.get_default_project()
-        config_default = config_manager.default_project
+        config_default = self.config_manager.default_project
 
         if db_default and db_default.name != config_default:
             # Update config to match DB default
             logger.info(f"Updating default project in config to '{db_default.name}'")
-            config_manager.set_default_project(db_default.name)
+            self.config_manager.set_default_project(db_default.name)
         elif not db_default and config_default:
             # Update DB to match config default (if the project exists)
             project = await self.repository.get_by_name(config_default)
@@ -292,6 +309,47 @@ class ProjectService:
             # MCP components might not be available in all contexts
             logger.debug("MCP session not available, skipping session refresh")
 
+    async def move_project(self, name: str, new_path: str) -> None:
+        """Move a project to a new location.
+
+        Args:
+            name: The name of the project to move
+            new_path: The new absolute path for the project
+
+        Raises:
+            ValueError: If the project doesn't exist or repository isn't initialized
+        """
+        if not self.repository:
+            raise ValueError("Repository is required for move_project")
+
+        # Resolve to absolute path
+        resolved_path = Path(os.path.abspath(os.path.expanduser(new_path))).as_posix()
+
+        # Validate project exists in config
+        if name not in self.config_manager.projects:
+            raise ValueError(f"Project '{name}' not found in configuration")
+
+        # Create the new directory if it doesn't exist
+        Path(resolved_path).mkdir(parents=True, exist_ok=True)
+
+        # Update in configuration
+        config = self.config_manager.load_config()
+        old_path = config.projects[name]
+        config.projects[name] = resolved_path
+        self.config_manager.save_config(config)
+
+        # Update in database using robust lookup
+        project = await self.get_project(name)
+        if project:
+            await self.repository.update_path(project.id, resolved_path)
+            logger.info(f"Moved project '{name}' from {old_path} to {resolved_path}")
+        else:
+            logger.error(f"Project '{name}' exists in config but not in database")
+            # Restore the old path in config since DB update failed
+            config.projects[name] = old_path
+            self.config_manager.save_config(config)
+            raise ValueError(f"Project '{name}' not found in database")
+
     async def update_project(  # pragma: no cover
         self, name: str, updated_path: Optional[str] = None, is_active: Optional[bool] = None
     ) -> None:
@@ -309,24 +367,23 @@ class ProjectService:
             raise ValueError("Repository is required for update_project")
 
         # Validate project exists in config
-        if name not in config_manager.projects:
+        if name not in self.config_manager.projects:
             raise ValueError(f"Project '{name}' not found in configuration")
 
-        # Get project from database
-        project = await self.repository.get_by_name(name)
+        # Get project from database using robust lookup
+        project = await self.get_project(name)
         if not project:
             logger.error(f"Project '{name}' exists in config but not in database")
             return
 
         # Update path if provided
         if updated_path:
-            resolved_path = os.path.abspath(os.path.expanduser(updated_path))
+            resolved_path = Path(os.path.abspath(os.path.expanduser(updated_path))).as_posix()
 
             # Update in config
-            projects = config_manager.config.projects.copy()
-            projects[name] = resolved_path
-            config_manager.config.projects = projects
-            config_manager.save_config(config_manager.config)
+            config = self.config_manager.load_config()
+            config.projects[name] = resolved_path
+            self.config_manager.save_config(config)
 
             # Update in database
             project.path = resolved_path
@@ -347,7 +404,7 @@ class ProjectService:
             if active_projects:
                 new_default = active_projects[0]
                 await self.repository.set_as_default(new_default.id)
-                config_manager.set_default_project(new_default.name)
+                self.config_manager.set_default_project(new_default.name)
                 logger.info(
                     f"Changed default project to '{new_default.name}' as '{name}' was deactivated"
                 )
@@ -365,9 +422,9 @@ class ProjectService:
             raise ValueError("Repository is required for get_project_info")
 
         # Use specified project or fall back to config project
-        project_name = project_name or config.project
+        project_name = project_name or self.config.project
         # Get project path from configuration
-        name, project_path = config_manager.get_project(project_name)
+        name, project_path = self.config_manager.get_project(project_name)
         if not name:  # pragma: no cover
             raise ValueError(f"Project '{project_name}' not found in configuration")
 
@@ -393,11 +450,11 @@ class ProjectService:
         db_projects_by_permalink = {p.permalink: p for p in db_projects}
 
         # Get default project info
-        default_project = config_manager.default_project
+        default_project = self.config_manager.default_project
 
         # Convert config projects to include database info
         enhanced_projects = {}
-        for name, path in config_manager.projects.items():
+        for name, path in self.config_manager.projects.items():
             config_permalink = generate_permalink(name)
             db_project = db_projects_by_permalink.get(config_permalink)
             enhanced_projects[name] = {
@@ -673,7 +730,7 @@ class ProjectService:
         import basic_memory
 
         # Get database information
-        db_path = app_config.database_path
+        db_path = self.config_manager.config.database_path
         db_size = db_path.stat().st_size if db_path.exists() else 0
         db_size_readable = f"{db_size / (1024 * 1024):.2f} MB"
 

basic_memory/sync/background_sync.py

@@ -2,7 +2,7 @@ import asyncio
 
 from loguru import logger
 
-from basic_memory.config import config as project_config
+from basic_memory.config import get_project_config
 from basic_memory.sync import SyncService, WatchService
 
 
@@ -11,9 +11,10 @@ async def sync_and_watch(
 ):  # pragma: no cover
     """Run sync and watch service."""
 
-    logger.info(f"Starting watch service to sync file changes in dir: {project_config.home}")
+    config = get_project_config()
+    logger.info(f"Starting watch service to sync file changes in dir: {config.home}")
     # full sync
-    await sync_service.sync(project_config.home)
+    await sync_service.sync(config.home)
 
     # watch changes
     await watch_service.run()

basic_memory/sync/sync_service.py

@@ -357,8 +357,8 @@ class SyncService:
 
             # get file timestamps
             file_stats = self.file_service.file_stats(path)
-            created = datetime.fromtimestamp(file_stats.st_ctime)
-            modified = datetime.fromtimestamp(file_stats.st_mtime)
+            created = datetime.fromtimestamp(file_stats.st_ctime).astimezone()
+            modified = datetime.fromtimestamp(file_stats.st_mtime).astimezone()
 
             # get mime type
             content_type = self.file_service.content_type(path)
@@ -453,6 +453,36 @@ class SyncService:
 
         entity = await self.entity_repository.get_by_file_path(old_path)
         if entity:
+            # Check if destination path is already occupied by another entity
+            existing_at_destination = await self.entity_repository.get_by_file_path(new_path)
+            if existing_at_destination and existing_at_destination.id != entity.id:
+                # Handle the conflict - this could be a file swap or replacement scenario
+                logger.warning(
+                    f"File path conflict detected during move: "
+                    f"entity_id={entity.id} trying to move from '{old_path}' to '{new_path}', "
+                    f"but entity_id={existing_at_destination.id} already occupies '{new_path}'"
+                )
+
+                # Check if this is a file swap (the destination entity is being moved to our old path)
+                # This would indicate a simultaneous move operation
+                old_path_after_swap = await self.entity_repository.get_by_file_path(old_path)
+                if old_path_after_swap and old_path_after_swap.id == existing_at_destination.id:
+                    logger.info(f"Detected file swap between '{old_path}' and '{new_path}'")
+                    # This is a swap scenario - both moves should succeed
+                    # We'll allow this to proceed since the other file has moved out
+                else:
+                    # This is a conflict where the destination is occupied
+                    raise ValueError(
+                        f"Cannot move entity from '{old_path}' to '{new_path}': "
+                        f"destination path is already occupied by another file. "
+                        f"This may be caused by: "
+                        f"1. Conflicting file names with different character encodings, "
+                        f"2. Case sensitivity differences (e.g., 'Finance/' vs 'finance/'), "
+                        f"3. Character conflicts between hyphens in filenames and generated permalinks, "
+                        f"4. Files with similar names containing special characters. "
+                        f"Try renaming one of the conflicting files to resolve this issue."
+                    )
+
             # Update file_path in all cases
             updates = {"file_path": new_path}
 
@@ -477,7 +507,26 @@ class SyncService:
                     f"new_checksum={new_checksum}"
                 )
 
-            updated = await self.entity_repository.update(entity.id, updates)
+            try:
+                updated = await self.entity_repository.update(entity.id, updates)
+            except Exception as e:
+                # Catch any database integrity errors and provide helpful context
+                if "UNIQUE constraint failed" in str(e):
+                    logger.error(
+                        f"Database constraint violation during move: "
+                        f"entity_id={entity.id}, old_path='{old_path}', new_path='{new_path}'"
+                    )
+                    raise ValueError(
+                        f"Cannot complete move from '{old_path}' to '{new_path}': "
+                        f"a database constraint was violated. This usually indicates "
+                        f"a file path or permalink conflict. Please check for: "
+                        f"1. Duplicate file names, "
+                        f"2. Case sensitivity issues (e.g., 'File.md' vs 'file.md'), "
+                        f"3. Character encoding conflicts in file names."
+                    ) from e
+                else:
+                    # Re-raise other exceptions as-is
+                    raise
 
             if updated is None:  # pragma: no cover
                 logger.error(
@@ -570,7 +619,7 @@ class SyncService:
                     continue
 
                 path = Path(root) / filename
-                rel_path = str(path.relative_to(directory))
+                rel_path = path.relative_to(directory).as_posix()
                 checksum = await self.file_service.compute_checksum(rel_path)
                 result.files[rel_path] = checksum
                 result.checksums[checksum] = rel_path

basic_memory/sync/watch_service.py

@@ -197,7 +197,7 @@ class WatchService:
 
         for change, path in changes:
             # convert to relative path
-            relative_path = str(Path(path).relative_to(directory))
+            relative_path = Path(path).relative_to(directory).as_posix()
 
             # Skip .tmp files - they're temporary and shouldn't be synced
             if relative_path.endswith(".tmp"):
@@ -284,13 +284,36 @@ class WatchService:
         # Process deletes
         for path in deletes:
             if path not in processed:
-                logger.debug("Processing deleted file", path=path)
-                await sync_service.handle_delete(path)
-                self.state.add_event(path=path, action="deleted", status="success")
-                self.console.print(f"[red]✕[/red] {path}")
-                logger.info(f"deleted: {path}")
-                processed.add(path)
-                delete_count += 1
+                # Check if file still exists on disk (vim atomic write edge case)
+                full_path = directory / path
+                if full_path.exists() and full_path.is_file():
+                    # File still exists despite DELETE event - treat as modification
+                    logger.debug("File exists despite DELETE event, treating as modification", path=path)
+                    entity, checksum = await sync_service.sync_file(path, new=False)
+                    self.state.add_event(path=path, action="modified", status="success", checksum=checksum)
+                    self.console.print(f"[yellow]✎[/yellow] {path} (atomic write)")
+                    logger.info(f"atomic write detected: {path}")
+                    processed.add(path)
+                    modify_count += 1
+                else:
+                    # Check if this was a directory - skip if so
+                    # (we can't tell if the deleted path was a directory since it no longer exists,
+                    # so we check if there's an entity in the database for it)
+                    entity = await sync_service.entity_repository.get_by_file_path(path)
+                    if entity is None:
+                        # No entity means this was likely a directory - skip it
+                        logger.debug(f"Skipping deleted path with no entity (likely directory), path={path}")
+                        processed.add(path)
+                        continue
+                    
+                    # File truly deleted
+                    logger.debug("Processing deleted file", path=path)
+                    await sync_service.handle_delete(path)
+                    self.state.add_event(path=path, action="deleted", status="success")
+                    self.console.print(f"[red]✕[/red] {path}")
+                    logger.info(f"deleted: {path}")
+                    processed.add(path)
+                    delete_count += 1
 
         # Process adds
         for path in adds: