Merge branch 'main' into feature/auto-format-on-save

Author: phernandez

src/basic_memory/alembic/versions/f8a9b2c3d4e5_add_pg_trgm_for_fuzzy_link_resolution.py

@@ -10,6 +10,42 @@
 
 import sqlalchemy as sa
 from alembic import op
+from sqlalchemy import text
+
+
+def column_exists(connection, table: str, column: str) -> bool:
+    """Check if a column exists in a table (idempotent migration support)."""
+    if connection.dialect.name == "postgresql":
+        result = connection.execute(
+            text(
+                "SELECT 1 FROM information_schema.columns "
+                "WHERE table_name = :table AND column_name = :column"
+            ),
+            {"table": table, "column": column},
+        )
+        return result.fetchone() is not None
+    else:
+        # SQLite
+        result = connection.execute(text(f"PRAGMA table_info({table})"))
+        columns = [row[1] for row in result]
+        return column in columns
+
+
+def index_exists(connection, index_name: str) -> bool:
+    """Check if an index exists (idempotent migration support)."""
+    if connection.dialect.name == "postgresql":
+        result = connection.execute(
+            text("SELECT 1 FROM pg_indexes WHERE indexname = :index_name"),
+            {"index_name": index_name},
+        )
+        return result.fetchone() is not None
+    else:
+        # SQLite
+        result = connection.execute(
+            text("SELECT 1 FROM sqlite_master WHERE type='index' AND name = :index_name"),
+            {"index_name": index_name},
+        )
+        return result.fetchone() is not None
 
 
 # revision identifiers, used by Alembic.
@@ -36,101 +72,105 @@ def upgrade() -> None:
     # Add project_id to relation table
     # -------------------------------------------------------------------------
 
-    # Step 1: Add project_id column as nullable first
-    op.add_column("relation", sa.Column("project_id", sa.Integer(), nullable=True))
+    # Step 1: Add project_id column as nullable first (idempotent)
+    if not column_exists(connection, "relation", "project_id"):
+        op.add_column("relation", sa.Column("project_id", sa.Integer(), nullable=True))
 
-    # Step 2: Backfill project_id from entity.project_id via from_id
-    if dialect == "postgresql":
-        op.execute("""
-            UPDATE relation
-            SET project_id = entity.project_id
-            FROM entity
-            WHERE relation.from_id = entity.id
-        """)
-    else:
-        # SQLite syntax
-        op.execute("""
-            UPDATE relation
-            SET project_id = (
-                SELECT entity.project_id
+        # Step 2: Backfill project_id from entity.project_id via from_id
+        if dialect == "postgresql":
+            op.execute("""
+                UPDATE relation
+                SET project_id = entity.project_id
                 FROM entity
-                WHERE entity.id = relation.from_id
-            )
-        """)
-
-    # Step 3: Make project_id NOT NULL and add foreign key
-    if dialect == "postgresql":
-        op.alter_column("relation", "project_id", nullable=False)
-        op.create_foreign_key(
-            "fk_relation_project_id",
-            "relation",
-            "project",
-            ["project_id"],
-            ["id"],
-        )
-    else:
-        # SQLite requires batch operations for ALTER COLUMN
-        with op.batch_alter_table("relation") as batch_op:
-            batch_op.alter_column("project_id", nullable=False)
-            batch_op.create_foreign_key(
+                WHERE relation.from_id = entity.id
+            """)
+        else:
+            # SQLite syntax
+            op.execute("""
+                UPDATE relation
+                SET project_id = (
+                    SELECT entity.project_id
+                    FROM entity
+                    WHERE entity.id = relation.from_id
+                )
+            """)
+
+        # Step 3: Make project_id NOT NULL and add foreign key
+        if dialect == "postgresql":
+            op.alter_column("relation", "project_id", nullable=False)
+            op.create_foreign_key(
                 "fk_relation_project_id",
+                "relation",
                 "project",
                 ["project_id"],
                 ["id"],
             )
-
-    # Step 4: Create index on relation.project_id
-    op.create_index("ix_relation_project_id", "relation", ["project_id"])
+        else:
+            # SQLite requires batch operations for ALTER COLUMN
+            with op.batch_alter_table("relation") as batch_op:
+                batch_op.alter_column("project_id", nullable=False)
+                batch_op.create_foreign_key(
+                    "fk_relation_project_id",
+                    "project",
+                    ["project_id"],
+                    ["id"],
+                )
+
+    # Step 4: Create index on relation.project_id (idempotent)
+    if not index_exists(connection, "ix_relation_project_id"):
+        op.create_index("ix_relation_project_id", "relation", ["project_id"])
 
     # -------------------------------------------------------------------------
     # Add project_id to observation table
     # -------------------------------------------------------------------------
 
-    # Step 1: Add project_id column as nullable first
-    op.add_column("observation", sa.Column("project_id", sa.Integer(), nullable=True))
+    # Step 1: Add project_id column as nullable first (idempotent)
+    if not column_exists(connection, "observation", "project_id"):
+        op.add_column("observation", sa.Column("project_id", sa.Integer(), nullable=True))
 
-    # Step 2: Backfill project_id from entity.project_id via entity_id
-    if dialect == "postgresql":
-        op.execute("""
-            UPDATE observation
-            SET project_id = entity.project_id
-            FROM entity
-            WHERE observation.entity_id = entity.id
-        """)
-    else:
-        # SQLite syntax
-        op.execute("""
-            UPDATE observation
-            SET project_id = (
-                SELECT entity.project_id
+        # Step 2: Backfill project_id from entity.project_id via entity_id
+        if dialect == "postgresql":
+            op.execute("""
+                UPDATE observation
+                SET project_id = entity.project_id
                 FROM entity
-                WHERE entity.id = observation.entity_id
-            )
-        """)
-
-    # Step 3: Make project_id NOT NULL and add foreign key
-    if dialect == "postgresql":
-        op.alter_column("observation", "project_id", nullable=False)
-        op.create_foreign_key(
-            "fk_observation_project_id",
-            "observation",
-            "project",
-            ["project_id"],
-            ["id"],
-        )
-    else:
-        # SQLite requires batch operations for ALTER COLUMN
-        with op.batch_alter_table("observation") as batch_op:
-            batch_op.alter_column("project_id", nullable=False)
-            batch_op.create_foreign_key(
+                WHERE observation.entity_id = entity.id
+            """)
+        else:
+            # SQLite syntax
+            op.execute("""
+                UPDATE observation
+                SET project_id = (
+                    SELECT entity.project_id
+                    FROM entity
+                    WHERE entity.id = observation.entity_id
+                )
+            """)
+
+        # Step 3: Make project_id NOT NULL and add foreign key
+        if dialect == "postgresql":
+            op.alter_column("observation", "project_id", nullable=False)
+            op.create_foreign_key(
                 "fk_observation_project_id",
+                "observation",
                 "project",
                 ["project_id"],
                 ["id"],
             )
-
-    # Step 4: Create index on observation.project_id
-    op.create_index("ix_observation_project_id", "observation", ["project_id"])
+        else:
+            # SQLite requires batch operations for ALTER COLUMN
+            with op.batch_alter_table("observation") as batch_op:
+                batch_op.alter_column("project_id", nullable=False)
+                batch_op.create_foreign_key(
+                    "fk_observation_project_id",
+                    "project",
+                    ["project_id"],
+                    ["id"],
+                )
+
+    # Step 4: Create index on observation.project_id (idempotent)
+    if not index_exists(connection, "ix_observation_project_id"):
+        op.create_index("ix_observation_project_id", "observation", ["project_id"])
 
     # Postgres-specific: pg_trgm and GIN indexes
     if dialect == "postgresql":

src/basic_memory/api/app.py

@@ -1,6 +1,7 @@
 """FastAPI application for basic-memory knowledge graph API."""
 
 import asyncio
+import os
 from contextlib import asynccontextmanager
 
 from fastapi import FastAPI, HTTPException
@@ -53,12 +54,25 @@ async def lifespan(app: FastAPI):  # pragma: no cover
     app.state.session_maker = session_maker
     logger.info("Database connections cached in app state")
 
-    logger.info(f"Sync changes enabled: {app_config.sync_changes}")
-    if app_config.sync_changes:
+    # Start file sync if enabled
+    is_test_env = (
+        app_config.env == "test"
+        or os.getenv("BASIC_MEMORY_ENV", "").lower() == "test"
+        or os.getenv("PYTEST_CURRENT_TEST") is not None
+    )
+    if app_config.sync_changes and not is_test_env:
+        logger.info(f"Sync changes enabled: {app_config.sync_changes}")
+
         # start file sync task in background
-        app.state.sync_task = asyncio.create_task(initialize_file_sync(app_config))
+        async def _file_sync_runner() -> None:
+            await initialize_file_sync(app_config)
+
+        app.state.sync_task = asyncio.create_task(_file_sync_runner())
     else:
-        logger.info("Sync changes disabled. Skipping file sync service.")
+        if is_test_env:
+            logger.info("Test environment detected. Skipping file sync service.")
+        else:
+            logger.info("Sync changes disabled. Skipping file sync service.")
         app.state.sync_task = None
 
     # proceed with startup

src/basic_memory/cli/app.py

@@ -34,8 +34,15 @@ def app_callback(
     # Initialize logging for CLI (file only, no stdout)
     init_cli_logging()
 
-    # Run initialization for every command unless --version was specified
-    if not version and ctx.invoked_subcommand is not None:
+    # Run initialization for commands that don't use the API
+    # Skip for 'mcp' command - it has its own lifespan that handles initialization
+    # Skip for API-using commands (status, sync, etc.) - they handle initialization via deps.py
+    api_commands = {"mcp", "status", "sync", "project", "tool"}
+    if (
+        not version
+        and ctx.invoked_subcommand is not None
+        and ctx.invoked_subcommand not in api_commands
+    ):
         from basic_memory.services.initialization import ensure_initialization
 
         app_config = ConfigManager().config

src/basic_memory/cli/commands/cloud/rclone_commands.py

@@ -9,18 +9,24 @@
 Replaces tenant-wide sync with project-scoped workflows.
 """
 
+import re
 import subprocess
 from dataclasses import dataclass
+from functools import lru_cache
 from pathlib import Path
 from typing import Optional
 
+from loguru import logger
 from rich.console import Console
 
 from basic_memory.cli.commands.cloud.rclone_installer import is_rclone_installed
 from basic_memory.utils import normalize_project_path
 
 console = Console()
 
+# Minimum rclone version for --create-empty-src-dirs support
+MIN_RCLONE_VERSION_EMPTY_DIRS = (1, 64, 0)
+
 
 class RcloneError(Exception):
     """Exception raised for rclone command errors."""
@@ -43,6 +49,42 @@ def check_rclone_installed() -> None:
         )
 
 
+@lru_cache(maxsize=1)
+def get_rclone_version() -> tuple[int, int, int] | None:
+    """Get rclone version as (major, minor, patch) tuple.
+
+    Returns:
+        Version tuple like (1, 64, 2), or None if version cannot be determined.
+
+    Note:
+        Result is cached since rclone version won't change during runtime.
+    """
+    try:
+        result = subprocess.run(["rclone", "version"], capture_output=True, text=True, timeout=10)
+        # Parse "rclone v1.64.2" or "rclone v1.60.1-DEV"
+        match = re.search(r"v(\d+)\.(\d+)\.(\d+)", result.stdout)
+        if match:
+            version = (int(match.group(1)), int(match.group(2)), int(match.group(3)))
+            logger.debug(f"Detected rclone version: {version}")
+            return version
+    except Exception as e:
+        logger.warning(f"Could not determine rclone version: {e}")
+    return None
+
+
+def supports_create_empty_src_dirs() -> bool:
+    """Check if installed rclone supports --create-empty-src-dirs flag.
+
+    Returns:
+        True if rclone version >= 1.64.0, False otherwise.
+    """
+    version = get_rclone_version()
+    if version is None:
+        # If we can't determine version, assume older and skip the flag
+        return False
+    return version >= MIN_RCLONE_VERSION_EMPTY_DIRS
+
+
 @dataclass
 class SyncProject:
     """Project configured for cloud sync.
@@ -218,7 +260,6 @@ def project_bisync(
         "bisync",
         str(local_path),
         remote_path,
-        "--create-empty-src-dirs",
         "--resilient",
         "--conflict-resolve=newer",
         "--max-delete=25",
@@ -229,6 +270,10 @@ def project_bisync(
         str(state_path),
     ]
 
+    # Add --create-empty-src-dirs if rclone version supports it (v1.64+)
+    if supports_create_empty_src_dirs():
+        cmd.append("--create-empty-src-dirs")
+
     if verbose:
         cmd.append("--verbose")
     else: