basic-memory 0.17.1__py3-none-any.whl

basic_memory/services/initialization.py

@@ -0,0 +1,216 @@
+"""Shared initialization service for Basic Memory.
+
+This module provides shared initialization functions used by both CLI and API
+to ensure consistent application startup across all entry points.
+"""
+
+import asyncio
+import os
+import sys
+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,
+)
+
+
+async def initialize_database(app_config: BasicMemoryConfig) -> None:
+    """Initialize database with migrations handled automatically by get_or_create_db.
+
+    Args:
+        app_config: The Basic Memory project configuration
+
+    Note:
+        Database migrations are now handled automatically when the database
+        connection is first established via get_or_create_db().
+    """
+    try:
+        await db.get_or_create_db(app_config.database_path)
+        logger.info("Database initialization completed")
+    except Exception as e:
+        logger.error(f"Error during database initialization: {e}")
+        raise
+
+
+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 (engine already created by initialize_database)
+    _, 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
+
+    # Create project service and synchronize projects
+    project_service = ProjectService(repository=project_repository)
+    try:
+        await project_service.synchronize_projects()
+        logger.info("Projects successfully reconciled between config and database")
+    except Exception as e:
+        logger.error(f"Error during project synchronization: {e}")
+        logger.info("Continuing with initialization despite synchronization error")
+
+
+async def initialize_file_sync(
+    app_config: BasicMemoryConfig,
+) -> None:
+    """Initialize file synchronization services. This function starts the watch service and does not return
+
+    Args:
+        app_config: The Basic Memory project configuration
+
+    Returns:
+        The watch service task that's monitoring file changes
+    """
+    # Never start file watching during tests. Even "background" watchers add tasks/threads
+    # and can interact badly with strict asyncio teardown (especially on Windows/aiosqlite).
+    # Skip file sync in test environments to avoid interference with tests
+    if app_config.is_test_env:
+        logger.info("Test environment detected - skipping file sync initialization")
+        return None
+
+    # delay import
+    from basic_memory.sync import WatchService
+
+    # Get database session (migrations already run if needed)
+    _, 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(
+        app_config=app_config,
+        project_repository=project_repository,
+        quiet=True,
+    )
+
+    # Get active projects
+    active_projects = await project_repository.get_active_projects()
+
+    # Filter to constrained project if MCP server was started with --project
+    constrained_project = os.environ.get("BASIC_MEMORY_MCP_PROJECT")
+    if constrained_project:
+        active_projects = [p for p in active_projects if p.name == constrained_project]
+        logger.info(f"Background sync constrained to project: {constrained_project}")
+
+    # Start sync for all projects as background tasks (non-blocking)
+    async def sync_project_background(project: Project):
+        """Sync a single project in the background."""
+        # avoid circular imports
+        from basic_memory.sync.sync_service import get_sync_service
+
+        logger.info(f"Starting background sync for project: {project.name}")
+        try:
+            # Create sync service
+            sync_service = await get_sync_service(project)
+
+            sync_dir = Path(project.path)
+            await sync_service.sync(sync_dir, project_name=project.name)
+            logger.info(f"Background sync completed successfully for project: {project.name}")
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Error in background sync for project {project.name}: {e}")
+
+    # Create background tasks for all project syncs (non-blocking)
+    sync_tasks = [
+        asyncio.create_task(sync_project_background(project)) for project in active_projects
+    ]
+    logger.info(f"Created {len(sync_tasks)} background sync tasks")
+
+    # Don't await the tasks - let them run in background while we continue
+
+    # Then start the watch service in the background
+    logger.info("Starting watch service for all projects")
+
+    # run the watch service
+    await watch_service.run()
+    logger.info("Watch service started")
+
+    return None
+
+
+async def initialize_app(
+    app_config: BasicMemoryConfig,
+):
+    """Initialize the Basic Memory application.
+
+    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
+    """
+    # Skip initialization in cloud mode - cloud manages its own projects
+    if app_config.cloud_mode_enabled:
+        logger.debug("Skipping initialization in cloud mode - projects managed by cloud")
+        return
+
+    logger.info("Initializing app...")
+    # Initialize database first
+    await initialize_database(app_config)
+
+    # Reconcile projects from config.json with projects table
+    await reconcile_projects_with_config(app_config)
+
+    logger.info("App initialization completed (migration running in background if needed)")
+
+
+def ensure_initialization(app_config: BasicMemoryConfig) -> None:
+    """Ensure initialization runs in a synchronous context.
+
+    This is a wrapper for the async initialize_app function that can be
+    called from synchronous code like CLI entry points.
+
+    No-op if app_config.cloud_mode == True. Cloud basic memory manages it's own projects
+
+    Args:
+        app_config: The Basic Memory project configuration
+    """
+    # Skip initialization in cloud mode - cloud manages its own projects
+    if app_config.cloud_mode_enabled:
+        logger.debug("Skipping initialization in cloud mode - projects managed by cloud")
+        return
+
+    async def _init_and_cleanup():
+        """Initialize app and clean up database connections.
+
+        Database connections created during initialization must be cleaned up
+        before the event loop closes, otherwise the process will hang indefinitely.
+        """
+        try:
+            await initialize_app(app_config)
+        finally:
+            # Always cleanup database connections to prevent process hang
+            await db.shutdown_db()
+
+    # On Windows, use SelectorEventLoop to avoid ProactorEventLoop cleanup issues
+    # The ProactorEventLoop can raise "IndexError: pop from an empty deque" during
+    # event loop cleanup when there are pending handles. SelectorEventLoop is more
+    # stable for our use case (no subprocess pipes or named pipes needed).
+    if sys.platform == "win32":
+        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
+
+    asyncio.run(_init_and_cleanup())
+    logger.info("Initialization completed successfully")

basic_memory/services/link_resolver.py

@@ -0,0 +1,121 @@
+"""Service for resolving markdown links to permalinks."""
+
+from typing import Optional, Tuple
+
+
+from loguru import logger
+
+from basic_memory.models import Entity
+from basic_memory.repository.entity_repository import EntityRepository
+from basic_memory.schemas.search import SearchQuery, SearchItemType
+from basic_memory.services.search_service import SearchService
+
+
+class LinkResolver:
+    """Service for resolving markdown links to permalinks.
+
+    Uses a combination of exact matching and search-based resolution:
+    1. Try exact permalink match (fastest)
+    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):
+        """Initialize with repositories."""
+        self.entity_repository = entity_repository
+        self.search_service = search_service
+
+    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)
+
+        # 1. Try exact permalink match first (most efficient)
+        entity = await self.entity_repository.get_by_permalink(clean_text)
+        if entity:
+            logger.debug(f"Found exact permalink match: {entity.permalink}")
+            return entity
+
+        # 2. Try exact title match
+        found = await self.entity_repository.get_by_title(clean_text)
+        if found:
+            # Return first match if there are duplicates (consistent behavior)
+            entity = found[0]
+            logger.debug(f"Found title match: {entity.title}")
+            return entity
+
+        # 3. Try file path
+        found_path = await self.entity_repository.get_by_file_path(clean_text)
+        if found_path:
+            logger.debug(f"Found entity with path: {found_path.file_path}")
+            return found_path
+
+        # 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:
+            results = await self.search_service.search(
+                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.trace(
+                    f"Selected best match from {len(results)} results: {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
+
+    def _normalize_link_text(self, link_text: str) -> Tuple[str, Optional[str]]:
+        """Normalize link text and extract alias if present.
+
+        Args:
+            link_text: Raw link text from markdown
+
+        Returns:
+            Tuple of (normalized_text, alias or None)
+        """
+        # Strip whitespace
+        text = link_text.strip()
+
+        # Remove enclosing brackets if present
+        if text.startswith("[[") and text.endswith("]]"):
+            text = text[2:-2]
+
+        # Handle Obsidian-style aliases (format: [[actual|alias]])
+        alias = None
+        if "|" in text:
+            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