basic-memory 0.12.3__py3-none-any.whl → 0.13.0__py3-none-any.whl

basic_memory/services/initialization.py

@@ -5,19 +5,18 @@ to ensure consistent application startup across all entry points.
 """
 
 import asyncio
-from typing import Optional
+import shutil
+from pathlib import Path
 
 from loguru import logger
 
 from basic_memory import db
-from basic_memory.config import ProjectConfig, config_manager
-from basic_memory.sync import WatchService
+from basic_memory.config import BasicMemoryConfig
+from basic_memory.models import Project
+from basic_memory.repository import ProjectRepository
 
-# Import this inside functions to avoid circular imports
-# from basic_memory.cli.commands.sync import get_sync_service
 
-
-async def initialize_database(app_config: ProjectConfig) -> None:
+async def initialize_database(app_config: BasicMemoryConfig) -> None:
     """Run database migrations to ensure schema is up to date.
 
     Args:
@@ -34,110 +33,215 @@ async def initialize_database(app_config: ProjectConfig) -> None:
         # more specific error if the database is actually unusable
 
 
+async def reconcile_projects_with_config(app_config: BasicMemoryConfig):
+    """Ensure all projects in config.json exist in the projects table and vice versa.
+
+    This uses the ProjectService's synchronize_projects method to ensure bidirectional
+    synchronization between the configuration file and the database.
+
+    Args:
+        app_config: The Basic Memory application configuration
+    """
+    logger.info("Reconciling projects from config with database...")
+
+    # Get database session
+    _, session_maker = await db.get_or_create_db(
+        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
+    )
+    project_repository = ProjectRepository(session_maker)
+
+    # Import ProjectService here to avoid circular imports
+    from basic_memory.services.project_service import ProjectService
+
+    try:
+        # Create project service and synchronize projects
+        project_service = ProjectService(repository=project_repository)
+        await project_service.synchronize_projects()
+        logger.info("Projects successfully reconciled between config and database")
+    except Exception as e:
+        # Log the error but continue with initialization
+        logger.error(f"Error during project synchronization: {e}")
+        logger.info("Continuing with initialization despite synchronization error")
+
+
+async def migrate_legacy_projects(app_config: BasicMemoryConfig):
+    # Get database session
+    _, session_maker = await db.get_or_create_db(
+        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
+    )
+    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: ProjectConfig,
-) -> asyncio.Task:
-    """Initialize file synchronization services.
+    app_config: BasicMemoryConfig,
+):
+    """Initialize file synchronization services. This function starts the watch service and does not return
 
     Args:
         app_config: The Basic Memory project configuration
 
     Returns:
-        Tuple of (sync_service, watch_service, watch_task) if sync is enabled,
-        or (None, None, None) if sync is disabled
+        The watch service task that's monitoring file changes
     """
-    # Load app configuration
-    # Import here to avoid circular imports
-    from basic_memory.cli.commands.sync import get_sync_service
 
-    # Initialize sync service
-    sync_service = await get_sync_service()
+    # delay import
+    from basic_memory.sync import WatchService
+
+    # Load app configuration
+    _, session_maker = await db.get_or_create_db(
+        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
+    )
+    project_repository = ProjectRepository(session_maker)
 
     # Initialize watch service
     watch_service = WatchService(
-        sync_service=sync_service,
-        file_service=sync_service.entity_service.file_service,
-        config=app_config,
+        app_config=app_config,
+        project_repository=project_repository,
         quiet=True,
     )
 
-    # Create the background task for running sync
-    async def run_background_sync():  # pragma: no cover
-        # Run initial full sync
-        await sync_service.sync(app_config.home)
-        logger.info("Sync completed successfully")
+    # Get active projects
+    active_projects = await project_repository.get_active_projects()
+
+    # First, sync all projects sequentially
+    for project in active_projects:
+        # avoid circular imports
+        from basic_memory.cli.commands.sync import get_sync_service
+
+        logger.info(f"Starting sync for project: {project.name}")
+        sync_service = await get_sync_service(project)
+        sync_dir = Path(project.path)
 
-        # Start background sync task
-        logger.info(f"Starting watch service to sync file changes in dir: {app_config.home}")
+        try:
+            await sync_service.sync(sync_dir, project_name=project.name)
+            logger.info(f"Sync completed successfully for project: {project.name}")
 
-        # Start watching for changes
+            # Mark project as watching for changes after successful sync
+            from basic_memory.services.sync_status_service import sync_status_tracker
+
+            sync_status_tracker.start_project_watch(project.name)
+            logger.info(f"Project {project.name} is now watching for changes")
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Error syncing project {project.name}: {e}")
+            # Mark sync as failed for this project
+            from basic_memory.services.sync_status_service import sync_status_tracker
+
+            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
+    try:
         await watch_service.run()
+        logger.info("Watch service started")
+    except Exception as e:  # pragma: no cover
+        logger.error(f"Error starting watch service: {e}")
 
-    watch_task = asyncio.create_task(run_background_sync())
-    logger.info("Watch service started")
-    return watch_task
+    return None
 
 
 async def initialize_app(
-    app_config: ProjectConfig,
-) -> Optional[asyncio.Task]:
+    app_config: BasicMemoryConfig,
+):
     """Initialize the Basic Memory application.
 
-    This function handles all initialization steps needed for both API and shor lived CLI commands.
-    For long running commands like mcp, a
+    This function handles all initialization steps:
     - Running database migrations
+    - Reconciling projects from config.json with projects table
     - Setting up file synchronization
+    - Starting background migration for legacy project data
 
     Args:
         app_config: The Basic Memory project configuration
     """
+    logger.info("Initializing app...")
     # Initialize database first
     await initialize_database(app_config)
 
-    basic_memory_config = config_manager.load_config()
-    logger.info(f"Sync changes enabled: {basic_memory_config.sync_changes}")
-    logger.info(
-        f"Update permalinks on move enabled: {basic_memory_config.update_permalinks_on_move}"
-    )
-    if not basic_memory_config.sync_changes:  # pragma: no cover
-        logger.info("Sync changes disabled. Skipping watch service.")
-        return
+    # Reconcile projects from config.json with projects table
+    await reconcile_projects_with_config(app_config)
 
-    # Initialize file sync services
-    return await initialize_file_sync(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)
 
-def ensure_initialization(app_config: ProjectConfig) -> None:
-    """Ensure initialization runs in a synchronous context.
+    logger.info("App initialization completed (migration running in background if needed)")
+    return migration_manager
 
-    This is a wrapper for the async initialize_app function that can be
-    called from synchronous code like CLI entry points.
 
-    Args:
-        app_config: The Basic Memory project configuration
-    """
-    try:
-        asyncio.run(initialize_app(app_config))
-    except Exception as e:
-        logger.error(f"Error during initialization: {e}")
-        # Continue execution even if initialization fails
-        # The command might still work, or will fail with a
-        # more specific error message
-
-
-def ensure_initialize_database(app_config: ProjectConfig) -> None:
+def ensure_initialization(app_config: BasicMemoryConfig) -> None:
     """Ensure initialization runs in a synchronous context.
 
-    This is a wrapper for the async initialize_database function that can be
+    This is a wrapper for the async initialize_app function that can be
     called from synchronous code like CLI entry points.
 
     Args:
         app_config: The Basic Memory project configuration
     """
     try:
-        asyncio.run(initialize_database(app_config))
-    except Exception as e:
-        logger.error(f"Error during initialization: {e}")
+        result = asyncio.run(initialize_app(app_config))
+        logger.info(f"Initialization completed successfully: result={result}")
+    except Exception as e:  # pragma: no cover
+        logger.exception(f"Error during initialization: {e}")
         # Continue execution even if initialization fails
         # The command might still work, or will fail with a
         # more specific error message

basic_memory/services/link_resolver.py

@@ -15,10 +15,10 @@ class LinkResolver:
 
     Uses a combination of exact matching and search-based resolution:
     1. Try exact permalink match (fastest)
-    2. Try permalink pattern match (for wildcards)
-    3. Try exact title match
-    4. Fall back to search for fuzzy matching
-    5. Generate new permalink if no match found
+    2. Try exact title match
+    3. Try exact file path match
+    4. Try file path with .md extension (for folder/title patterns)
+    5. Fall back to search for fuzzy matching
     """
 
     def __init__(self, entity_repository: EntityRepository, search_service: SearchService):
@@ -26,9 +26,17 @@ class LinkResolver:
         self.entity_repository = entity_repository
         self.search_service = search_service
 
-    async def resolve_link(self, link_text: str, use_search: bool = True) -> Optional[Entity]:
-        """Resolve a markdown link to a permalink."""
-        logger.debug(f"Resolving link: {link_text}")
+    async def resolve_link(
+        self, link_text: str, use_search: bool = True, strict: bool = False
+    ) -> Optional[Entity]:
+        """Resolve a markdown link to a permalink.
+
+        Args:
+            link_text: The link text to resolve
+            use_search: Whether to use search-based fuzzy matching as fallback
+            strict: If True, only exact matches are allowed (no fuzzy search fallback)
+        """
+        logger.trace(f"Resolving link: {link_text}")
 
         # Clean link text and extract any alias
         clean_text, alias = self._normalize_link_text(link_text)
@@ -41,7 +49,8 @@ class LinkResolver:
 
         # 2. Try exact title match
         found = await self.entity_repository.get_by_title(clean_text)
-        if found and len(found) == 1:
+        if found:
+            # Return first match if there are duplicates (consistent behavior)
             entity = found[0]
             logger.debug(f"Found title match: {entity.title}")
             return entity
@@ -52,17 +61,28 @@ class LinkResolver:
             logger.debug(f"Found entity with path: {found_path.file_path}")
             return found_path
 
-        # search if indicated
+        # 4. Try file path with .md extension if not already present
+        if not clean_text.endswith(".md") and "/" in clean_text:
+            file_path_with_md = f"{clean_text}.md"
+            found_path_md = await self.entity_repository.get_by_file_path(file_path_with_md)
+            if found_path_md:
+                logger.debug(f"Found entity with path (with .md): {found_path_md.file_path}")
+                return found_path_md
+
+        # In strict mode, don't try fuzzy search - return None if no exact match found
+        if strict:
+            return None
+
+        # 5. Fall back to search for fuzzy matching (only if not in strict mode)
         if use_search and "*" not in clean_text:
-            # 3. Fall back to search for fuzzy matching on title
             results = await self.search_service.search(
-                query=SearchQuery(title=clean_text, entity_types=[SearchItemType.ENTITY]),
+                query=SearchQuery(text=clean_text, entity_types=[SearchItemType.ENTITY]),
             )
 
             if results:
                 # Look for best match
                 best_match = min(results, key=lambda x: x.score)  # pyright: ignore
-                logger.debug(
+                logger.trace(
                     f"Selected best match from {len(results)} results: {best_match.permalink}"
                 )
                 if best_match.permalink:
@@ -93,5 +113,8 @@ class LinkResolver:
             text, alias = text.split("|", 1)
             text = text.strip()
             alias = alias.strip()
+        else:
+            # Strip whitespace from text even if no alias
+            text = text.strip()
 
         return text, alias

basic_memory/services/migration_service.py

@@ -0,0 +1,168 @@
+"""Migration service for handling background migrations and status tracking."""
+
+import asyncio
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Optional
+
+from loguru import logger
+
+from basic_memory.config import BasicMemoryConfig
+
+
+class MigrationStatus(Enum):
+    """Status of migration operations."""
+
+    NOT_NEEDED = "not_needed"
+    PENDING = "pending"
+    IN_PROGRESS = "in_progress"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class MigrationState:
+    """Current state of migration operations."""
+
+    status: MigrationStatus
+    message: str
+    progress: Optional[str] = None
+    error: Optional[str] = None
+    projects_migrated: int = 0
+    projects_total: int = 0
+
+
+class MigrationManager:
+    """Manages background migration operations and status tracking."""
+
+    def __init__(self):
+        self._state = MigrationState(
+            status=MigrationStatus.NOT_NEEDED, message="No migration required"
+        )
+        self._migration_task: Optional[asyncio.Task] = None
+
+    @property
+    def state(self) -> MigrationState:
+        """Get current migration state."""
+        return self._state
+
+    @property
+    def is_ready(self) -> bool:
+        """Check if the system is ready for normal operations."""
+        return self._state.status in (MigrationStatus.NOT_NEEDED, MigrationStatus.COMPLETED)
+
+    @property
+    def status_message(self) -> str:
+        """Get a user-friendly status message."""
+        if self._state.status == MigrationStatus.IN_PROGRESS:
+            progress = (
+                f" ({self._state.projects_migrated}/{self._state.projects_total})"
+                if self._state.projects_total > 0
+                else ""
+            )
+            return f"🔄 File sync in progress{progress}: {self._state.message}. Use sync_status() tool for details."
+        elif self._state.status == MigrationStatus.FAILED:
+            return f"❌ File sync failed: {self._state.error or 'Unknown error'}. Use sync_status() tool for details."
+        elif self._state.status == MigrationStatus.COMPLETED:
+            return "✅ File sync completed successfully"
+        else:
+            return "✅ System ready"
+
+    async def check_migration_needed(self, app_config: BasicMemoryConfig) -> bool:
+        """Check if migration is needed without performing it."""
+        from basic_memory import db
+        from basic_memory.repository import ProjectRepository
+
+        try:
+            # Get database session
+            _, session_maker = await db.get_or_create_db(
+                db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
+            )
+            project_repository = ProjectRepository(session_maker)
+
+            # Check for legacy projects
+            legacy_projects = []
+            for project_name, project_path in app_config.projects.items():
+                legacy_dir = Path(project_path) / ".basic-memory"
+                if legacy_dir.exists():
+                    project = await project_repository.get_by_name(project_name)
+                    if project:
+                        legacy_projects.append(project)
+
+            if legacy_projects:
+                self._state = MigrationState(
+                    status=MigrationStatus.PENDING,
+                    message="Legacy projects detected",
+                    projects_total=len(legacy_projects),
+                )
+                return True
+            else:
+                self._state = MigrationState(
+                    status=MigrationStatus.NOT_NEEDED, message="No migration required"
+                )
+                return False
+
+        except Exception as e:
+            logger.error(f"Error checking migration status: {e}")
+            self._state = MigrationState(
+                status=MigrationStatus.FAILED, message="Migration check failed", error=str(e)
+            )
+            return False
+
+    async def start_background_migration(self, app_config: BasicMemoryConfig) -> None:
+        """Start migration in background if needed."""
+        if not await self.check_migration_needed(app_config):
+            return
+
+        if self._migration_task and not self._migration_task.done():
+            logger.info("Migration already in progress")
+            return
+
+        logger.info("Starting background migration")
+        self._migration_task = asyncio.create_task(self._run_migration(app_config))
+
+    async def _run_migration(self, app_config: BasicMemoryConfig) -> None:
+        """Run the actual migration process."""
+        try:
+            self._state.status = MigrationStatus.IN_PROGRESS
+            self._state.message = "Migrating legacy projects"
+
+            # Import here to avoid circular imports
+            from basic_memory.services.initialization import migrate_legacy_projects
+
+            # Run the migration
+            await migrate_legacy_projects(app_config)
+
+            self._state = MigrationState(
+                status=MigrationStatus.COMPLETED, message="Migration completed successfully"
+            )
+            logger.info("Background migration completed successfully")
+
+        except Exception as e:
+            logger.error(f"Background migration failed: {e}")
+            self._state = MigrationState(
+                status=MigrationStatus.FAILED, message="Migration failed", error=str(e)
+            )
+
+    async def wait_for_completion(self, timeout: Optional[float] = None) -> bool:
+        """Wait for migration to complete."""
+        if self.is_ready:
+            return True
+
+        if not self._migration_task:
+            return False
+
+        try:
+            await asyncio.wait_for(self._migration_task, timeout=timeout)
+            return self.is_ready
+        except asyncio.TimeoutError:
+            return False
+
+    def mark_completed(self, message: str = "Migration completed") -> None:
+        """Mark migration as completed externally."""
+        self._state = MigrationState(status=MigrationStatus.COMPLETED, message=message)
+
+
+# Global migration manager instance
+migration_manager = MigrationManager()