basic-memory 0.12.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

basic_memory/__init__.py

@@ -1,3 +1,3 @@
 """basic-memory - Local-first knowledge management combining Zettelkasten with knowledge graphs"""
 
-__version__ = "0.12.0"
+__version__ = "0.12.1"

basic_memory/api/app.py

@@ -1,6 +1,5 @@
 """FastAPI application for basic-memory knowledge graph API."""
 
-import asyncio
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI, HTTPException
@@ -10,44 +9,14 @@ from loguru import logger
 from basic_memory import db
 from basic_memory.api.routers import knowledge, memory, project_info, resource, search
 from basic_memory.config import config as project_config
-from basic_memory.config import config_manager
-from basic_memory.sync import SyncService, WatchService
-
-
-async def run_background_sync(sync_service: SyncService, watch_service: WatchService): # pragma: no cover
-    logger.info(f"Starting watch service to sync file changes in dir: {project_config.home}")
-    # full sync
-    await sync_service.sync(project_config.home, show_progress=False)
-
-    # watch changes
-    await watch_service.run()
+from basic_memory.services.initialization import initialize_app
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):  # pragma: no cover
     """Lifecycle manager for the FastAPI app."""
-    await db.run_migrations(project_config)
-
-    # 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}")
-
-    watch_task = None
-    if basic_memory_config.sync_changes:
-        # import after migrations have run
-        from basic_memory.cli.commands.sync import get_sync_service
-
-        sync_service = await get_sync_service()
-        watch_service = WatchService(
-            sync_service=sync_service,
-            file_service=sync_service.entity_service.file_service,
-            config=project_config,
-        )
-        watch_task = asyncio.create_task(run_background_sync(sync_service, watch_service))
-    else:
-        logger.info("Sync changes disabled. Skipping watch service.")
-
+    # Initialize database and file sync services
+    watch_task = await initialize_app(project_config)
 
     # proceed with startup
     yield

basic_memory/cli/app.py

@@ -7,8 +7,11 @@ def version_callback(value: bool) -> None:
     """Show version and exit."""
     if value:  # pragma: no cover
         import basic_memory
+        from basic_memory.config import config
 
         typer.echo(f"Basic Memory version: {basic_memory.__version__}")
+        typer.echo(f"Current project: {config.project}")
+        typer.echo(f"Project path: {config.home}")
         raise typer.Exit()
 
 
@@ -17,11 +20,12 @@ app = typer.Typer(name="basic-memory")
 
 @app.callback()
 def app_callback(
+    ctx: typer.Context,
     project: Optional[str] = typer.Option(
         None,
         "--project",
         "-p",
-        help="Specify which project to use",
+        help="Specify which project to use 1",
         envvar="BASIC_MEMORY_PROJECT",
     ),
     version: Optional[bool] = typer.Option(
@@ -34,6 +38,7 @@ def app_callback(
     ),
 ) -> None:
     """Basic Memory - Local-first personal knowledge management."""
+
     # We use the project option to set the BASIC_MEMORY_PROJECT environment variable
     # The config module will pick this up when loading
     if project:  # pragma: no cover
@@ -53,6 +58,13 @@ def app_callback(
 
         config = new_config
 
+    # Run migrations for every command unless --version was specified
+    if not version and ctx.invoked_subcommand is not None:
+        from basic_memory.config import config
+        from basic_memory.services.initialization import ensure_initialize_database
+
+        ensure_initialize_database(config)
+
 
 # Register sub-command groups
 import_app = typer.Typer(help="Import data from various sources")

basic_memory/cli/commands/mcp.py

@@ -1,10 +1,7 @@
 """MCP server command."""
 
-from loguru import logger
-
 import basic_memory
 from basic_memory.cli.app import app
-from basic_memory.config import config, config_manager
 
 # Import mcp instance
 from basic_memory.mcp.server import mcp as mcp_server  # pragma: no cover
@@ -15,19 +12,24 @@ import basic_memory.mcp.tools  # noqa: F401  # pragma: no cover
 
 @app.command()
 def mcp():  # pragma: no cover
-    """Run the MCP server for Claude Desktop integration."""
-    home_dir = config.home
-    project_name = config.project
+    """Run the MCP server"""
+    from basic_memory.config import config
+    import asyncio
+    from basic_memory.services.initialization import initialize_database
+
+    # First, run just the database migrations synchronously
+    asyncio.run(initialize_database(config))
+
+    # Load config to check if sync is enabled
+    from basic_memory.config import config_manager
 
-    # app config
     basic_memory_config = config_manager.load_config()
 
-    logger.info(f"Starting Basic Memory MCP server {basic_memory.__version__}")
-    logger.info(f"Project: {project_name}")
-    logger.info(f"Project directory: {home_dir}")
-    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 basic_memory_config.sync_changes:
+        # For now, we'll just log that sync will be handled by the MCP server
+        from loguru import logger
+
+        logger.info("File sync will be handled by the MCP server")
 
+    # Start the MCP server
     mcp_server.run()

basic_memory/cli/commands/sync.py

@@ -179,14 +179,14 @@ async def run_sync(verbose: bool = False, watch: bool = False, console_status: b
         )
 
         # full sync - no progress bars in watch mode
-        await sync_service.sync(config.home, show_progress=False)
+        await sync_service.sync(config.home)
 
         # watch changes
         await watch_service.run()  # pragma: no cover
     else:
-        # one time sync - use progress bars for better UX
+        # one time sync
         logger.info("Running one-time sync")
-        knowledge_changes = await sync_service.sync(config.home, show_progress=True)
+        knowledge_changes = await sync_service.sync(config.home)
 
         # Log results
         duration_ms = int((time.time() - start_time) * 1000)
@@ -237,11 +237,11 @@ def sync(
         if not isinstance(e, typer.Exit):
             logger.exception(
                 "Sync command failed",
-                project=config.project,
-                error=str(e),
-                error_type=type(e).__name__,
-                watch_mode=watch,
-                directory=str(config.home),
+                f"project={config.project},"
+                f"error={str(e)},"
+                f"error_type={type(e).__name__},"
+                f"watch_mode={watch},"
+                f"directory={str(config.home)}",
             )
             typer.echo(f"Error during sync: {e}", err=True)
             raise typer.Exit(1)

basic_memory/cli/main.py

@@ -1,9 +1,5 @@
 """Main CLI entry point for basic-memory."""  # pragma: no cover
 
-import asyncio
-
-import typer
-
 from basic_memory.cli.app import app  # pragma: no cover
 
 # Register commands
@@ -20,48 +16,11 @@ from basic_memory.cli.commands import (  # noqa: F401  # pragma: no cover
     tool,
 )
 from basic_memory.config import config
-from basic_memory.db import run_migrations as db_run_migrations
-
-
-# Version command
-@app.callback(invoke_without_command=True)
-def main(
-    ctx: typer.Context,
-    project: str = typer.Option(  # noqa
-        "main",
-        "--project",
-        "-p",
-        help="Specify which project to use",
-        envvar="BASIC_MEMORY_PROJECT",
-    ),
-    version: bool = typer.Option(
-        False,
-        "--version",
-        "-V",
-        help="Show version information and exit.",
-        is_eager=True,
-    ),
-):
-    """Basic Memory - Local-first personal knowledge management system."""
-    if version:  # pragma: no cover
-        from basic_memory import __version__
-        from basic_memory.config import config
-
-        typer.echo(f"Basic Memory v{__version__}")
-        typer.echo(f"Current project: {config.project}")
-        typer.echo(f"Project path: {config.home}")
-        raise typer.Exit()
-
-    # Handle project selection via environment variable
-    if project:
-        import os
-
-        os.environ["BASIC_MEMORY_PROJECT"] = project
-
+from basic_memory.services.initialization import ensure_initialization
 
 if __name__ == "__main__":  # pragma: no cover
-    # Run database migrations
-    asyncio.run(db_run_migrations(config))
+    # Run initialization if we are starting as a module
+    ensure_initialization(config)
 
     # start the app
     app()

basic_memory/config.py

@@ -35,7 +35,7 @@ class ProjectConfig(BaseSettings):
 
     # Watch service configuration
     sync_delay: int = Field(
-        default=500, description="Milliseconds to wait after changes before syncing", gt=0
+        default=1000, description="Milliseconds to wait after changes before syncing", gt=0
     )
 
     # update permalinks on move
@@ -274,7 +274,7 @@ def setup_basic_memory_logging():  # pragma: no cover
         console=False,
     )
 
-    logger.info(f"Starting Basic Memory {basic_memory.__version__} (Project: {config.project})")
+    logger.info(f"Basic Memory {basic_memory.__version__} (Project: {config.project})")
     _LOGGING_SETUP = True
 
 

basic_memory/mcp/server.py

@@ -1,11 +1,37 @@
 """Enhanced FastMCP server instance for Basic Memory."""
 
+import asyncio
+from contextlib import asynccontextmanager
+from typing import AsyncIterator, Optional
+
 from mcp.server.fastmcp import FastMCP
-from mcp.server.fastmcp.utilities.logging import configure_logging
+from mcp.server.fastmcp.utilities.logging import configure_logging as mcp_configure_logging
+from dataclasses import dataclass
+
+from basic_memory.config import config as project_config
+from basic_memory.services.initialization import initialize_app
 
 # mcp console logging
-configure_logging(level="ERROR")
+mcp_configure_logging(level="ERROR")
+
+
+@dataclass
+class AppContext:
+    watch_task: Optional[asyncio.Task]
+
+
+@asynccontextmanager
+async def app_lifespan(server: FastMCP) -> AsyncIterator[AppContext]:  # pragma: no cover
+    """Manage application lifecycle with type-safe context"""
+    # Initialize on startup
+    watch_task = await initialize_app(project_config)
+    try:
+        yield AppContext(watch_task=watch_task)
+    finally:
+        # Cleanup on shutdown
+        if watch_task:
+            watch_task.cancel()
 
 
 # Create the shared server instance
-mcp = FastMCP("Basic Memory", log_level="ERROR")
+mcp = FastMCP("Basic Memory", log_level="ERROR", lifespan=app_lifespan)

basic_memory/repository/repository.py

@@ -137,8 +137,6 @@ class Repository[T: Base]:
 
     async def find_one(self, query: Select[tuple[T]]) -> Optional[T]:
         """Execute a query and retrieve a single record."""
-        logger.debug(f"Finding one {self.Model.__name__} with query: {query}")
-
         # add in load options
         query = query.options(*self.get_load_options())
         result = await self.execute_query(query)
@@ -270,11 +268,9 @@ class Repository[T: Base]:
         """Execute a query asynchronously."""
 
         query = query.options(*self.get_load_options()) if use_query_options else query
-
         logger.debug(f"Executing query: {query}")
         async with db.scoped_session(self.session_maker) as session:
             result = await session.execute(query)
-            logger.debug("Query executed successfully")
             return result
 
     def get_load_options(self) -> List[LoaderOption]:

basic_memory/services/file_service.py

@@ -60,7 +60,7 @@ class FileService:
         Returns:
             Raw content string without metadata sections
         """
-        logger.debug("Reading entity content", entity_id=entity.id, permalink=entity.permalink)
+        logger.debug(f"Reading entity content, entity_id={entity.id}, permalink={entity.permalink}")
 
         file_path = self.get_entity_path(entity)
         markdown = await self.markdown_processor.read_file(file_path)

basic_memory/services/initialization.py

@@ -0,0 +1,143 @@
+"""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
+from typing import Optional
+
+from loguru import logger
+
+from basic_memory import db
+from basic_memory.config import ProjectConfig, config_manager
+from basic_memory.sync import WatchService
+
+# 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:
+    """Run database migrations to ensure schema is up to date.
+
+    Args:
+        app_config: The Basic Memory project configuration
+    """
+    try:
+        logger.info("Running database migrations...")
+        await db.run_migrations(app_config)
+        logger.info("Migrations completed successfully")
+    except Exception as e:
+        logger.error(f"Error running migrations: {e}")
+        # Allow application to continue - it might still work
+        # depending on what the error was, and will fail with a
+        # more specific error if the database is actually unusable
+
+
+async def initialize_file_sync(
+    app_config: ProjectConfig,
+) -> asyncio.Task:
+    """Initialize file synchronization services.
+
+    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
+    """
+    # 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()
+
+    # Initialize watch service
+    watch_service = WatchService(
+        sync_service=sync_service,
+        file_service=sync_service.entity_service.file_service,
+        config=app_config,
+        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")
+
+        # Start background sync task
+        logger.info(f"Starting watch service to sync file changes in dir: {app_config.home}")
+
+        # Start watching for changes
+        await watch_service.run()
+
+    watch_task = asyncio.create_task(run_background_sync())
+    logger.info("Watch service started")
+    return watch_task
+
+
+async def initialize_app(
+    app_config: ProjectConfig,
+) -> Optional[asyncio.Task]:
+    """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
+    - Running database migrations
+    - Setting up file synchronization
+
+    Args:
+        app_config: The Basic Memory project configuration
+    """
+    # 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
+
+    # Initialize file sync services
+    return await initialize_file_sync(app_config)
+
+
+def ensure_initialization(app_config: ProjectConfig) -> 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.
+
+    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:
+    """Ensure initialization runs in a synchronous context.
+
+    This is a wrapper for the async initialize_database 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}")
+        # Continue execution even if initialization fails
+        # The command might still work, or will fail with a
+        # more specific error message

basic_memory/sync/sync_service.py

@@ -19,7 +19,6 @@ from basic_memory.repository import EntityRepository, RelationRepository
 from basic_memory.services import EntityService, FileService
 from basic_memory.services.search_service import SearchService
 import time
-from rich.progress import Progress, TextColumn, BarColumn, TaskProgressColumn
 
 
 @dataclass
@@ -83,145 +82,51 @@ class SyncService:
         self.search_service = search_service
         self.file_service = file_service
 
-    async def sync(self, directory: Path, show_progress: bool = True) -> SyncReport:
+    async def sync(self, directory: Path) -> SyncReport:
         """Sync all files with database."""
 
         start_time = time.time()
-        console = None
-        progress = None  # Will be initialized if show_progress is True
-
-        logger.info("Sync operation started", directory=str(directory))
+        logger.info(f"Sync operation started for directory: {directory}")
 
         # initial paths from db to sync
         # path -> checksum
-        if show_progress:
-            from rich.console import Console
-
-            console = Console()
-            console.print(f"Scanning directory: {directory}")
-
         report = await self.scan(directory)
 
         # Initialize progress tracking if requested
-        if show_progress and report.total > 0:
-            progress = Progress(
-                TextColumn("[bold blue]{task.description}"),
-                BarColumn(),
-                TaskProgressColumn(),
-                console=console,
-                expand=True,
-            )
-
         # order of sync matters to resolve relations effectively
         logger.info(
-            "Sync changes detected",
-            new_files=len(report.new),
-            modified_files=len(report.modified),
-            deleted_files=len(report.deleted),
-            moved_files=len(report.moves),
+            f"Sync changes detected: new_files={len(report.new)}, modified_files={len(report.modified)}, "
+            + f"deleted_files={len(report.deleted)}, moved_files={len(report.moves)}"
         )
 
-        if show_progress and report.total > 0:
-            with progress:  # pyright: ignore
-                # Track each category separately
-                move_task = None
-                if report.moves:  # pragma: no cover
-                    move_task = progress.add_task("[blue]Moving files...", total=len(report.moves))  # pyright: ignore
-
-            delete_task = None
-            if report.deleted:  # pragma: no cover
-                delete_task = progress.add_task(  # pyright: ignore
-                    "[red]Deleting files...", total=len(report.deleted)
-                )
-
-            new_task = None
-            if report.new:
-                new_task = progress.add_task(  # pyright: ignore
-                    "[green]Adding new files...", total=len(report.new)
-                )
-
-            modify_task = None
-            if report.modified:  # pragma: no cover
-                modify_task = progress.add_task(  # pyright: ignore
-                    "[yellow]Updating modified files...", total=len(report.modified)
+        # sync moves first
+        for old_path, new_path in report.moves.items():
+            # in the case where a file has been deleted and replaced by another file
+            # it will show up in the move and modified lists, so handle it in modified
+            if new_path in report.modified:
+                report.modified.remove(new_path)
+                logger.debug(
+                    f"File marked as moved and modified: old_path={old_path}, new_path={new_path}"
                 )
+            else:
+                await self.handle_move(old_path, new_path)
 
-            # sync moves first
-            for i, (old_path, new_path) in enumerate(report.moves.items()):
-                # in the case where a file has been deleted and replaced by another file
-                # it will show up in the move and modified lists, so handle it in modified
-                if new_path in report.modified:  # pragma: no cover
-                    report.modified.remove(new_path)
-                    logger.debug(
-                        "File marked as moved and modified",
-                        old_path=old_path,
-                        new_path=new_path,
-                        action="processing as modified",
-                    )
-                else:  # pragma: no cover
-                    await self.handle_move(old_path, new_path)
-
-                if move_task is not None:  # pragma: no cover
-                    progress.update(move_task, advance=1)  # pyright: ignore
-
-            # deleted next
-            for i, path in enumerate(report.deleted):  # pragma: no cover
-                await self.handle_delete(path)
-                if delete_task is not None:  # pragma: no cover
-                    progress.update(delete_task, advance=1)  # pyright: ignore
-
-            # then new and modified
-            for i, path in enumerate(report.new):
-                await self.sync_file(path, new=True)
-                if new_task is not None:
-                    progress.update(new_task, advance=1)  # pyright: ignore
-
-            for i, path in enumerate(report.modified):  # pragma: no cover
-                await self.sync_file(path, new=False)
-                if modify_task is not None:  # pragma: no cover
-                    progress.update(modify_task, advance=1)  # pyright: ignore
-
-            # Final step - resolving relations
-            if report.total > 0:
-                relation_task = progress.add_task("[cyan]Resolving relations...", total=1)  # pyright: ignore
-                await self.resolve_relations()
-                progress.update(relation_task, advance=1)  # pyright: ignore
-        else:
-            # No progress display - proceed with normal sync
-            # sync moves first
-            for old_path, new_path in report.moves.items():
-                # in the case where a file has been deleted and replaced by another file
-                # it will show up in the move and modified lists, so handle it in modified
-                if new_path in report.modified:
-                    report.modified.remove(new_path)
-                    logger.debug(
-                        "File marked as moved and modified",
-                        old_path=old_path,
-                        new_path=new_path,
-                        action="processing as modified",
-                    )
-                else:
-                    await self.handle_move(old_path, new_path)
-
-            # deleted next
-            for path in report.deleted:
-                await self.handle_delete(path)
+        # deleted next
+        for path in report.deleted:
+            await self.handle_delete(path)
 
-            # then new and modified
-            for path in report.new:
-                await self.sync_file(path, new=True)
+        # then new and modified
+        for path in report.new:
+            await self.sync_file(path, new=True)
 
-            for path in report.modified:
-                await self.sync_file(path, new=False)
+        for path in report.modified:
+            await self.sync_file(path, new=False)
 
-            await self.resolve_relations()
+        await self.resolve_relations()
 
         duration_ms = int((time.time() - start_time) * 1000)
         logger.info(
-            "Sync operation completed",
-            directory=str(directory),
-            total_changes=report.total,
-            duration_ms=duration_ms,
+            f"Sync operation completed: directory={directory}, total_changes={report.total}, duration_ms={duration_ms}"
         )
 
         return report
@@ -230,6 +135,7 @@ class SyncService:
         """Scan directory for changes compared to database state."""
 
         db_paths = await self.get_db_file_state()
+        logger.debug(f"Found {len(db_paths)} db paths")
 
         # Track potentially moved files by checksum
         scan_result = await self.scan_directory(directory)
@@ -280,6 +186,7 @@ class SyncService:
             :param db_records: the data from the db
         """
         db_records = await self.entity_repository.find_all()
+        logger.info(f"Found {len(db_records)} db records")
         return {r.file_path: r.checksum or "" for r in db_records}
 
     async def sync_file(
@@ -296,10 +203,7 @@ class SyncService:
         """
         try:
             logger.debug(
-                "Syncing file",
-                path=path,
-                is_new=new,
-                is_markdown=self.file_service.is_markdown(path),
+                f"Syncing file path={path} is_new={new} is_markdown={self.file_service.is_markdown(path)}"
             )
 
             if self.file_service.is_markdown(path):
@@ -311,7 +215,7 @@ class SyncService:
                 await self.search_service.index_entity(entity)
 
                 logger.debug(
-                    "File sync completed", path=path, entity_id=entity.id, checksum=checksum
+                    f"File sync completed, path={path}, entity_id={entity.id}, checksum={checksum[:8]}"
                 )
             return entity, checksum
 
@@ -330,7 +234,7 @@ class SyncService:
             Tuple of (entity, checksum)
         """
         # Parse markdown first to get any existing permalink
-        logger.debug("Parsing markdown file", path=path)
+        logger.debug(f"Parsing markdown file, path: {path}, new: {new}")
 
         file_path = self.entity_parser.base_path / path
         file_content = file_path.read_text()
@@ -347,10 +251,7 @@ class SyncService:
             # If permalink changed, update the file
             if permalink != entity_markdown.frontmatter.permalink:
                 logger.info(
-                    "Updating permalink",
-                    path=path,
-                    old_permalink=entity_markdown.frontmatter.permalink,
-                    new_permalink=permalink,
+                    f"Updating permalink for path: {path}, old_permalink: {entity_markdown.frontmatter.permalink}, new_permalink: {permalink}"
                 )
 
                 entity_markdown.frontmatter.metadata["permalink"] = permalink
@@ -359,12 +260,12 @@ class SyncService:
         # if the file is new, create an entity
         if new:
             # Create entity with final permalink
-            logger.debug("Creating new entity from markdown", path=path)
+            logger.debug(f"Creating new entity from markdown, path={path}")
             await self.entity_service.create_entity_from_markdown(Path(path), entity_markdown)
 
         # otherwise we need to update the entity and observations
         else:
-            logger.debug("Updating entity from markdown", path=path)
+            logger.debug(f"Updating entity from markdown, path={path}")
             await self.entity_service.update_entity_and_observations(Path(path), entity_markdown)
 
         # Update relations and search index
@@ -379,12 +280,9 @@ class SyncService:
         await self.entity_repository.update(entity.id, {"checksum": final_checksum})
 
         logger.debug(
-            "Markdown sync completed",
-            path=path,
-            entity_id=entity.id,
-            observation_count=len(entity.observations),
-            relation_count=len(entity.relations),
-            checksum=final_checksum,
+            f"Markdown sync completed: path={path}, entity_id={entity.id}, "
+            f"observation_count={len(entity.observations)}, relation_count={len(entity.relations)}, "
+            f"checksum={final_checksum[:8]}"
         )
 
         # Return the final checksum to ensure everything is consistent
@@ -429,7 +327,7 @@ class SyncService:
         else:
             entity = await self.entity_repository.get_by_file_path(path)
             if entity is None:  # pragma: no cover
-                logger.error("Entity not found for existing file", path=path)
+                logger.error(f"Entity not found for existing file, path={path}")
                 raise ValueError(f"Entity not found for existing file: {path}")
 
             updated = await self.entity_repository.update(
@@ -437,7 +335,7 @@ class SyncService:
             )
 
             if updated is None:  # pragma: no cover
-                logger.error("Failed to update entity", entity_id=entity.id, path=path)
+                logger.error(f"Failed to update entity, entity_id={entity.id}, path={path}")
                 raise ValueError(f"Failed to update entity with ID {entity.id}")
 
             return updated, checksum
@@ -449,10 +347,7 @@ class SyncService:
         entity = await self.entity_repository.get_by_file_path(file_path)
         if entity:
             logger.info(
-                "Deleting entity",
-                file_path=file_path,
-                entity_id=entity.id,
-                permalink=entity.permalink,
+                f"Deleting entity with file_path={file_path}, entity_id={entity.id}, permalink={entity.permalink}"
             )
 
             # Delete from db (this cascades to observations/relations)
@@ -466,10 +361,8 @@ class SyncService:
             )
 
             logger.debug(
-                "Cleaning up search index",
-                entity_id=entity.id,
-                file_path=file_path,
-                index_entries=len(permalinks),
+                f"Cleaning up search index for entity_id={entity.id}, file_path={file_path}, "
+                f"index_entries={len(permalinks)}"
             )
 
             for permalink in permalinks:
@@ -479,7 +372,7 @@ class SyncService:
                     await self.search_service.delete_by_entity_id(entity.id)
 
     async def handle_move(self, old_path, new_path):
-        logger.info("Moving entity", old_path=old_path, new_path=new_path)
+        logger.debug("Moving entity", old_path=old_path, new_path=new_path)
 
         entity = await self.entity_repository.get_by_file_path(old_path)
         if entity:
@@ -500,29 +393,28 @@ class SyncService:
                 updates["checksum"] = new_checksum
 
                 logger.info(
-                    "Updating permalink on move",
-                    old_permalink=entity.permalink,
-                    new_permalink=new_permalink,
-                    new_checksum=new_checksum,
+                    f"Updating permalink on move,old_permalink={entity.permalink}"
+                    f"new_permalink={new_permalink}"
+                    f"new_checksum={new_checksum}"
                 )
 
             updated = await self.entity_repository.update(entity.id, updates)
 
             if updated is None:  # pragma: no cover
                 logger.error(
-                    "Failed to update entity path",
-                    entity_id=entity.id,
-                    old_path=old_path,
-                    new_path=new_path,
+                    "Failed to update entity path"
+                    f"entity_id={entity.id}"
+                    f"old_path={old_path}"
+                    f"new_path={new_path}"
                 )
                 raise ValueError(f"Failed to update entity path for ID {entity.id}")
 
             logger.debug(
-                "Entity path updated",
-                entity_id=entity.id,
-                permalink=entity.permalink,
-                old_path=old_path,
-                new_path=new_path,
+                "Entity path updated"
+                f"entity_id={entity.id} "
+                f"permalink={entity.permalink} "
+                f"old_path={old_path} "
+                f"new_path={new_path} "
             )
 
             # update search index
@@ -537,10 +429,10 @@ class SyncService:
 
         for relation in unresolved_relations:
             logger.debug(
-                "Attempting to resolve relation",
-                relation_id=relation.id,
-                from_id=relation.from_id,
-                to_name=relation.to_name,
+                "Attempting to resolve relation "
+                f"relation_id={relation.id} "
+                f"from_id={relation.from_id} "
+                f"to_name={relation.to_name}"
             )
 
             resolved_entity = await self.entity_service.link_resolver.resolve_link(relation.to_name)
@@ -548,12 +440,12 @@ class SyncService:
             # ignore reference to self
             if resolved_entity and resolved_entity.id != relation.from_id:
                 logger.debug(
-                    "Resolved forward reference",
-                    relation_id=relation.id,
-                    from_id=relation.from_id,
-                    to_name=relation.to_name,
-                    resolved_id=resolved_entity.id,
-                    resolved_title=resolved_entity.title,
+                    "Resolved forward reference "
+                    f"relation_id={relation.id} "
+                    f"from_id={relation.from_id} "
+                    f"to_name={relation.to_name} "
+                    f"resolved_id={resolved_entity.id} "
+                    f"resolved_title={resolved_entity.title}",
                 )
                 try:
                     await self.relation_repository.update(
@@ -565,10 +457,10 @@ class SyncService:
                     )
                 except IntegrityError:  # pragma: no cover
                     logger.debug(
-                        "Ignoring duplicate relation",
-                        relation_id=relation.id,
-                        from_id=relation.from_id,
-                        to_name=relation.to_name,
+                        "Ignoring duplicate relation "
+                        f"relation_id={relation.id} "
+                        f"from_id={relation.from_id} "
+                        f"to_name={relation.to_name}"
                     )
 
                 # update search index
@@ -586,7 +478,7 @@ class SyncService:
         """
         start_time = time.time()
 
-        logger.debug("Scanning directory", directory=str(directory))
+        logger.debug(f"Scanning directory {directory}")
         result = ScanResult()
 
         for root, dirnames, filenames in os.walk(str(directory)):
@@ -608,10 +500,10 @@ class SyncService:
 
         duration_ms = int((time.time() - start_time) * 1000)
         logger.debug(
-            "Directory scan completed",
-            directory=str(directory),
-            files_found=len(result.files),
-            duration_ms=duration_ms,
+            f"{directory} scan completed "
+            f"directory={str(directory)} "
+            f"files_found={len(result.files)} "
+            f"duration_ms={duration_ms}"
         )
 
         return result

basic_memory/sync/watch_service.py

@@ -70,22 +70,30 @@ class WatchServiceState(BaseModel):
 
 
 class WatchService:
-    def __init__(self, sync_service: SyncService, file_service: FileService, config: ProjectConfig):
+    def __init__(
+        self,
+        sync_service: SyncService,
+        file_service: FileService,
+        config: ProjectConfig,
+        quiet: bool = False,
+    ):
         self.sync_service = sync_service
         self.file_service = file_service
         self.config = config
         self.state = WatchServiceState()
         self.status_path = config.home / ".basic-memory" / WATCH_STATUS_JSON
         self.status_path.parent.mkdir(parents=True, exist_ok=True)
-        self.console = Console()
+
+        # quiet mode for mcp so it doesn't mess up stdout
+        self.console = Console(quiet=quiet)
 
     async def run(self):  # pragma: no cover
         """Watch for file changes and sync them"""
         logger.info(
             "Watch service started",
-            directory=str(self.config.home),
-            debounce_ms=self.config.sync_delay,
-            pid=os.getpid(),
+            f"directory={str(self.config.home)}",
+            f"debounce_ms={self.config.sync_delay}",
+            f"pid={os.getpid()}",
         )
 
         self.state.running = True
@@ -111,8 +119,8 @@ class WatchService:
         finally:
             logger.info(
                 "Watch service stopped",
-                directory=str(self.config.home),
-                runtime_seconds=int((datetime.now() - self.state.start_time).total_seconds()),
+                f"directory={str(self.config.home)}",
+                f"runtime_seconds={int((datetime.now() - self.state.start_time).total_seconds())}",
             )
 
             self.state.running = False
@@ -154,7 +162,7 @@ class WatchService:
 
         start_time = time.time()
 
-        logger.info("Processing file changes", change_count=len(changes), directory=str(directory))
+        logger.info(f"Processing file changes, change_count={len(changes)}, directory={directory}")
 
         # Group changes by type
         adds: List[str] = []
@@ -177,9 +185,17 @@ class WatchService:
                 modifies.append(relative_path)
 
         logger.debug(
-            "Grouped file changes", added=len(adds), deleted=len(deletes), modified=len(modifies)
+            f"Grouped file changes, added={len(adds)}, deleted={len(deletes)}, modified={len(modifies)}"
         )
 
+        # because of our atomic writes on updates, an add may be an existing file
+        for added_path in adds:  # pragma: no cover TODO add test
+            entity = await self.sync_service.entity_repository.get_by_file_path(added_path)
+            if entity is not None:
+                logger.debug(f"Existing file will be processed as modified, path={added_path}")
+                adds.remove(added_path)
+                modifies.append(added_path)
+
         # Track processed files to avoid duplicates
         processed: Set[str] = set()
 
@@ -223,15 +239,16 @@ class WatchService:
                                 status="success",
                             )
                             self.console.print(f"[blue]→[/blue] {deleted_path} → {added_path}")
+                            logger.info(f"move: {deleted_path} -> {added_path}")
                             processed.add(added_path)
                             processed.add(deleted_path)
                             break
                     except Exception as e:  # pragma: no cover
                         logger.warning(
                             "Error checking for move",
-                            old_path=deleted_path,
-                            new_path=added_path,
-                            error=str(e),
+                            f"old_path={deleted_path}",
+                            f"new_path={added_path}",
+                            f"error={str(e)}",
                         )
 
         # Handle remaining changes - group them by type for concise output
@@ -247,6 +264,7 @@ class WatchService:
                 await self.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
 
@@ -257,28 +275,27 @@ class WatchService:
                 full_path = directory / path
                 if not full_path.exists() or full_path.is_dir():
                     logger.debug(
-                        "Skipping non-existent or directory path", path=path
+                        f"Skipping non-existent or directory path, path={path}"
                     )  # pragma: no cover
                     processed.add(path)  # pragma: no cover
                     continue  # pragma: no cover
 
-                logger.debug("Processing new file", path=path)
+                logger.debug(f"Processing new file, path={path}")
                 entity, checksum = await self.sync_service.sync_file(path, new=True)
                 if checksum:
                     self.state.add_event(
                         path=path, action="new", status="success", checksum=checksum
                     )
                     self.console.print(f"[green]✓[/green] {path}")
-                    logger.debug(
-                        "Added file processed",
-                        path=path,
-                        entity_id=entity.id if entity else None,
-                        checksum=checksum,
+                    logger.info(
+                        "new file processed",
+                        f"path={path}",
+                        f"checksum={checksum}",
                     )
                     processed.add(path)
                     add_count += 1
                 else:  # pragma: no cover
-                    logger.warning("Error syncing new file", path=path)  # pragma: no cover
+                    logger.warning(f"Error syncing new file, path={path}")  # pragma: no cover
                     self.console.print(
                         f"[orange]?[/orange] Error syncing: {path}"
                     )  # pragma: no cover
@@ -296,7 +313,7 @@ class WatchService:
                     processed.add(path)
                     continue
 
-                logger.debug("Processing modified file", path=path)
+                logger.debug(f"Processing modified file: path={path}")
                 entity, checksum = await self.sync_service.sync_file(path, new=False)
                 self.state.add_event(
                     path=path, action="modified", status="success", checksum=checksum
@@ -311,17 +328,18 @@ class WatchService:
                             f"[yellow]...[/yellow] Repeated changes to {path}"
                         )  # pragma: no cover
                 else:
-                    # New file being modified
+                    # haven't processed this file
                     self.console.print(f"[yellow]✎[/yellow] {path}")
+                    logger.info(f"modified: {path}")
                     last_modified_path = path
                     repeat_count = 0
                     modify_count += 1
 
                 logger.debug(
-                    "Modified file processed",
-                    path=path,
-                    entity_id=entity.id if entity else None,
-                    checksum=checksum,
+                    "Modified file processed, "
+                    f"path={path} "
+                    f"entity_id={entity.id if entity else None} "
+                    f"checksum={checksum}",
                 )
                 processed.add(path)
 
@@ -339,16 +357,17 @@ class WatchService:
 
             if changes:
                 self.console.print(f"{', '.join(changes)}", style="dim")  # pyright: ignore
+                logger.info(f"changes: {len(changes)}")
 
         duration_ms = int((time.time() - start_time) * 1000)
         self.state.last_scan = datetime.now()
         self.state.synced_files += len(processed)
 
         logger.info(
-            "File change processing completed",
-            processed_files=len(processed),
-            total_synced_files=self.state.synced_files,
-            duration_ms=duration_ms,
+            "File change processing completed, "
+            f"processed_files={len(processed)}, "
+            f"total_synced_files={self.state.synced_files}, "
+            f"duration_ms={duration_ms}"
         )
 
         await self.write_status()

{basic_memory-0.12.0.dist-info → basic_memory-0.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: basic-memory
-Version: 0.12.0
+Version: 0.12.1
 Summary: Local-first knowledge management combining Zettelkasten with knowledge graphs
 Project-URL: Homepage, https://github.com/basicmachines-co/basic-memory
 Project-URL: Repository, https://github.com/basicmachines-co/basic-memory
@@ -187,7 +187,7 @@ The note embeds semantic content and links to other topics via simple Markdown f
 
 3. You see this file on your computer in real time in the current project directory (default `~/$HOME/basic-memory`).
 
-- Realtime sync can be enabled via running `basic-memory sync --watch`
+- Realtime sync is enabled by default with the v0.12.0 version
 
 4. In a chat with the LLM, you can reference a topic:
 
@@ -378,13 +378,7 @@ config:
 
 2. Sync your knowledge:
 
-```bash
-# One-time sync of local knowledge updates
-basic-memory sync
-
-# Run realtime sync process (recommended)
-basic-memory sync --watch
-```
+Basic Memory will sync the files in your project in real time if you make manual edits.
 
 3. In Claude Desktop, the LLM can now use these tools:
 

{basic_memory-0.12.0.dist-info → basic_memory-0.12.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-basic_memory/__init__.py,sha256=RtfHqJWLL9RssuJgBRYNskTtP0k1jVVukaswAEsHjfU,123
-basic_memory/config.py,sha256=ONdKTjIS_W2d0k6epzV0dY0Gdv8OC_woBkK-ElXpxW8,9211
+basic_memory/__init__.py,sha256=45SW0xM0KuIkvy6KfeAwERAglEya26oqmJ0WvHoG_gA,123
+basic_memory/config.py,sha256=jZmBOj4Gl2l56pApiN88s6juPDaX1g2LcvuVUnUeG0Q,9203
 basic_memory/db.py,sha256=8SmrmNAlJlmYT9yIJiPwNq8SN8mB2rbW5t33Rqpyl2I,6052
 basic_memory/deps.py,sha256=yI6RL_5-8LXw7ywSJ_84BXAczDtv2h9GFLw-E9XDJFg,5770
 basic_memory/file_utils.py,sha256=eaxTKLLEbTIy_Mb_Iv_Dmt4IXAJSrZGVi-Knrpyci3E,6700
@@ -13,7 +13,7 @@ basic_memory/alembic/versions/502b60eaa905_remove_required_from_entity_permalink
 basic_memory/alembic/versions/b3c3938bacdb_relation_to_name_unique_index.py,sha256=RsGymQzfRXV1LSNKiyi0lMilTxW1NgwS9jR67ye2apI,1428
 basic_memory/alembic/versions/cc7172b46608_update_search_index_schema.py,sha256=Lbo3dEzdId_vKRFe3jMkGFF3dNQpblPIQa4Bh7np-zA,4020
 basic_memory/api/__init__.py,sha256=wCpj-21j1D0KzKl9Ql6unLBVFY0K1uGp_FeSZRKtqpk,72
-basic_memory/api/app.py,sha256=yoVghdAdkPrnYRdtSgUEJ1tS1FAjfxpGOh40DVL9myQ,2896
+basic_memory/api/app.py,sha256=GFFX3MOusEzbDaAVDECk3B46xybuinUfMt4Atw0Nr8c,1724
 basic_memory/api/routers/__init__.py,sha256=SKuL-weA58hYj0NOMCQRfmsaumlNjjyVHDXNpRO38bQ,305
 basic_memory/api/routers/knowledge_router.py,sha256=iYuBguMb6ERitAwoelSejBYJqLTGfjpkzAHrqwTKjVE,5876
 basic_memory/api/routers/memory_router.py,sha256=W_uHJe2c4XN96mFj6XNvUH6INVbl1BMxy0KUchLcbxU,5421
@@ -21,18 +21,18 @@ basic_memory/api/routers/project_info_router.py,sha256=Qv12_QL3SRpo7bPcpAjizJmkZ
 basic_memory/api/routers/resource_router.py,sha256=WEJEqEaY_yTKj5-U-rW4kXQKUcJflykgwI6_g_R41ck,8058
 basic_memory/api/routers/search_router.py,sha256=R_a5OF5_8rCjmoOMhmw3M4VLCy6I1KLGJ-otSLB0rbI,1953
 basic_memory/cli/__init__.py,sha256=arcKLAWRDhPD7x5t80MlviZeYzwHZ0GZigyy3NKVoGk,33
-basic_memory/cli/app.py,sha256=qTalo-Pk2zJCa6u4xQD0ORkCnu_e1Bjw0stPIJWdmxQ,1655
-basic_memory/cli/main.py,sha256=52mBF4HWBG0WGlqXzwn5pDpVFNap51aNEimybZ28lpM,1656
+basic_memory/cli/app.py,sha256=hFRYznTSI58t6FEDUwF_PUgKZF0V63sCHzBDDb5FOAk,2142
+basic_memory/cli/main.py,sha256=WhYOCKliF48DLDOukOg3QPiD16IP3AJfhdCIe7Wlh2g,666
 basic_memory/cli/commands/__init__.py,sha256=3oojcC-Y-4RPqff9vtwWziT_T4uvBVicL0pSHNilVkU,393
 basic_memory/cli/commands/db.py,sha256=-jgVH2fs_s1vvBNJx_FWspQVHv0F6Qd7V5ZPxtYn_jQ,1125
 basic_memory/cli/commands/import_chatgpt.py,sha256=M4_oUN9o_BaW5jpKQu2pTEybivB5ccVolhdZzmhLOsI,8162
 basic_memory/cli/commands/import_claude_conversations.py,sha256=D_4-0xFKkZka7xFvvW8OkgjLv3TFqsC_VuB2Z-Y3avU,6827
 basic_memory/cli/commands/import_claude_projects.py,sha256=KzUuf3wrlvJlqTWCzoLRrNxD3OYNteRXaTFj5IB1FA8,6649
 basic_memory/cli/commands/import_memory_json.py,sha256=zqpU4eCzQXx04aRsigddJAyhvklmTgSAzeRTuEdNw0c,5194
-basic_memory/cli/commands/mcp.py,sha256=01yBzmFAwxqDUvTQWu--aynvWlHD8P8D3syYUqGJFQw,998
+basic_memory/cli/commands/mcp.py,sha256=sWwRLRbY_FYUNxoy1a8risypnjS9YvZbnP3IjijiUZ0,1025
 basic_memory/cli/commands/project.py,sha256=BSjdz07xDM3R4CUXggv1qhrWLJsEgvGFir6aOUzdr2Q,11330
 basic_memory/cli/commands/status.py,sha256=nbs3myxaNtehEEJ4BBngPuKs-vqZTHNCCb0bTgDsE-s,5277
-basic_memory/cli/commands/sync.py,sha256=3MD99jZuIQ16cKx6mvOtsCZR7FGFPU9Bb1WUQAb6VVY,8374
+basic_memory/cli/commands/sync.py,sha256=3jwgabxkF4WyFZ-gRC1l8A8p8Z_aYrzHRXOtUfYy2yc,8324
 basic_memory/cli/commands/tool.py,sha256=7wte1TqjG__NcC7BB0BRLl8THB3t5eAngud0zVHBQ8k,9506
 basic_memory/markdown/__init__.py,sha256=DdzioCWtDnKaq05BHYLgL_78FawEHLpLXnp-kPSVfIc,501
 basic_memory/markdown/entity_parser.py,sha256=I4K1Uq8kLYBmShIZQuXI9FuQjzpoV924-jDH9dIiYb8,4420
@@ -43,7 +43,7 @@ basic_memory/markdown/utils.py,sha256=wr7KnDMThgnztkOoqSG_ANPhwNBoPkyjYP1sA1Wnxe
 basic_memory/mcp/__init__.py,sha256=dsDOhKqjYeIbCULbHIxfcItTbqudEuEg1Np86eq0GEQ,35
 basic_memory/mcp/async_client.py,sha256=Eo345wANiBRSM4u3j_Vd6Ax4YtMg7qbWd9PIoFfj61I,236
 basic_memory/mcp/main.py,sha256=0kbcyf1PxRC1bLnHv2zzParfJ6cOq7Am9ScF9UoI50U,703
-basic_memory/mcp/server.py,sha256=xrgG602nqrS6XZAUYl-KfpEFH78eKtJMO0WyKo4H9VE,307
+basic_memory/mcp/server.py,sha256=RgNIyRUsuBgoCntj_5Dn2_QNTBYQ1tjFSEn-Z1PoFzU,1099
 basic_memory/mcp/prompts/__init__.py,sha256=-Bl9Dgj2TD9PULjzggPqXuvPEjWCRy7S9Yg03h2-U7A,615
 basic_memory/mcp/prompts/ai_assistant_guide.py,sha256=8TI5xObiRVcwv6w9by1xQHlX0whvyE7-LGsiqDMRTFg,821
 basic_memory/mcp/prompts/continue_conversation.py,sha256=I1FdNXIsSBKsu2ABj8TRRr-mdZKZ1K8LMCUfAik5Iqs,4424
@@ -71,7 +71,7 @@ basic_memory/repository/entity_repository.py,sha256=VLKlQ97-_HhSqc-st_YToWUNE4pJ
 basic_memory/repository/observation_repository.py,sha256=BOcy4wARqCXu-thYyt7mPxt2A2C8TW0le3s_X9wrK6I,1701
 basic_memory/repository/project_info_repository.py,sha256=nHWzs0WBQ366WfzIYZgnAfU6tyQ_8slEszWNlDSeIlo,336
 basic_memory/repository/relation_repository.py,sha256=DwpTcn9z_1sZQcyMOUABz1k1VSwo_AU63x2zR7aerTk,2933
-basic_memory/repository/repository.py,sha256=cZFCjp7Q-fKwjEYe3ubG1rgYbPEQXsocAn9LgFNXCG0,12071
+basic_memory/repository/repository.py,sha256=X03U6FA3tpQ8FoULL7J7GByUeArSc2Ajb5GIJjZ8HBA,11934
 basic_memory/repository/search_repository.py,sha256=z6oX6wCLo2JaW2hawtgiyxmTsboKTjuO7cgXsFsQhmA,11607
 basic_memory/schemas/__init__.py,sha256=KHzF2lZhYXRsH2g6tV5Oivlk1EHFfrlbKuiRllqnBzs,1570
 basic_memory/schemas/base.py,sha256=dwnaI5fJXsdp81mdH0ZpmJ-WICY-0M7ZPWeW5OUgBG8,5685
@@ -85,15 +85,16 @@ basic_memory/services/__init__.py,sha256=oop6SKmzV4_NAYt9otGnupLGVCCKIVgxEcdRQWw
 basic_memory/services/context_service.py,sha256=vUo4j-_UDDlpL_PxoNTqmG5kZ2m7UfPyIz6FY3SCU7o,9715
 basic_memory/services/entity_service.py,sha256=lCdqRnAkaolt_pr48lFxRXAj2YRS-nasJTkepBf3zlU,12915
 basic_memory/services/exceptions.py,sha256=VGlCLd4UD2w5NWKqC7QpG4jOM_hA7jKRRM-MqvEVMNk,288
-basic_memory/services/file_service.py,sha256=7uLVkcFMFj20srdch8c6u9T6nO5X4wHgcXdL81pGV88,9935
+basic_memory/services/file_service.py,sha256=egoJnhoHBUX_wepjkLyyc6qZkPfOexlj8p0HRvtdxWw,9940
+basic_memory/services/initialization.py,sha256=T8KPFpFzeURORPjvfhvHE7Vnmx_TXUUGumBCEEiCJaM,4787
 basic_memory/services/link_resolver.py,sha256=3I3wp5HHpe17DNHhn1IG3_yWWHYtEZKRNL7I2j_AHos,3599
 basic_memory/services/search_service.py,sha256=1K1YuWFVreKjn6LkbOpl-zCmXYjqOQS1qB-yvkwu-zc,9817
 basic_memory/services/service.py,sha256=V-d_8gOV07zGIQDpL-Ksqs3ZN9l3qf3HZOK1f_YNTag,336
 basic_memory/sync/__init__.py,sha256=CVHguYH457h2u2xoM8KvOilJC71XJlZ-qUh8lHcjYj4,156
-basic_memory/sync/sync_service.py,sha256=R0mBgTRQP_o55ldzn4Il876D1eXVyJo32cgLcPjQPXk,23611
-basic_memory/sync/watch_service.py,sha256=IliisNN8HMKLnBaF95wGHpA5WqRWujprWJVxOnAQ2yc,13468
-basic_memory-0.12.0.dist-info/METADATA,sha256=jtcnzL11Nr6pAEBENRwEUu5Z0qfHmGM7dyrxtap8ULQ,15054
-basic_memory-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-basic_memory-0.12.0.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
-basic_memory-0.12.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
-basic_memory-0.12.0.dist-info/RECORD,,
+basic_memory/sync/sync_service.py,sha256=UYIHk6ACVLo34RLg08voo_vDosNh_pua3HEXY9JM2zw,19610
+basic_memory/sync/watch_service.py,sha256=ipkW9zK1MhisvdHambB9sesB6vNm0OapMZZM7w0GmsQ,14338
+basic_memory-0.12.1.dist-info/METADATA,sha256=zdQD7uRrb9DBoBS8XM362yUZ5nd-w3PFARc4E7BIMAI,14992
+basic_memory-0.12.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+basic_memory-0.12.1.dist-info/entry_points.txt,sha256=wvE2mRF6-Pg4weIYcfQ-86NOLZD4WJg7F7TIsRVFLb8,90
+basic_memory-0.12.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+basic_memory-0.12.1.dist-info/RECORD,,