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

basic_memory/cli/commands/sync.py

@@ -16,10 +16,12 @@ from basic_memory.cli.app import app
 from basic_memory.config import config
 from basic_memory.markdown import EntityParser
 from basic_memory.markdown.markdown_processor import MarkdownProcessor
+from basic_memory.models import Project
 from basic_memory.repository import (
     EntityRepository,
     ObservationRepository,
     RelationRepository,
+    ProjectRepository,
 )
 from basic_memory.repository.search_repository import SearchRepository
 from basic_memory.services import EntityService, FileService
@@ -27,7 +29,7 @@ from basic_memory.services.link_resolver import LinkResolver
 from basic_memory.services.search_service import SearchService
 from basic_memory.sync import SyncService
 from basic_memory.sync.sync_service import SyncReport
-from basic_memory.sync.watch_service import WatchService
+from basic_memory.config import app_config
 
 console = Console()
 
@@ -38,21 +40,22 @@ class ValidationIssue:
     error: str
 
 
-async def get_sync_service():  # pragma: no cover
+async def get_sync_service(project: Project) -> SyncService:  # pragma: no cover
     """Get sync service instance with all dependencies."""
     _, session_maker = await db.get_or_create_db(
-        db_path=config.database_path, db_type=db.DatabaseType.FILESYSTEM
+        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
     )
 
-    entity_parser = EntityParser(config.home)
+    project_path = Path(project.path)
+    entity_parser = EntityParser(project_path)
     markdown_processor = MarkdownProcessor(entity_parser)
-    file_service = FileService(config.home, markdown_processor)
+    file_service = FileService(project_path, markdown_processor)
 
     # Initialize repositories
-    entity_repository = EntityRepository(session_maker)
-    observation_repository = ObservationRepository(session_maker)
-    relation_repository = RelationRepository(session_maker)
-    search_repository = SearchRepository(session_maker)
+    entity_repository = EntityRepository(session_maker, project_id=project.id)
+    observation_repository = ObservationRepository(session_maker, project_id=project.id)
+    relation_repository = RelationRepository(session_maker, project_id=project.id)
+    search_repository = SearchRepository(session_maker, project_id=project.id)
 
     # Initialize services
     search_service = SearchService(search_repository, entity_repository, file_service)
@@ -70,7 +73,7 @@ async def get_sync_service():  # pragma: no cover
 
     # Create sync service
     sync_service = SyncService(
-        config=config,
+        app_config=app_config,
         entity_service=entity_service,
         entity_parser=entity_parser,
         entity_repository=entity_repository,
@@ -153,8 +156,16 @@ def display_detailed_sync_results(knowledge: SyncReport):
         console.print(knowledge_tree)
 
 
-async def run_sync(verbose: bool = False, watch: bool = False, console_status: bool = False):
+async def run_sync(verbose: bool = False):
     """Run sync operation."""
+    _, session_maker = await db.get_or_create_db(
+        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
+    )
+    project_repository = ProjectRepository(session_maker)
+    project = await project_repository.get_by_name(config.project)
+    if not project:  # pragma: no cover
+        raise Exception(f"Project '{config.project}' not found")
+
     import time
 
     start_time = time.time()
@@ -162,50 +173,33 @@ async def run_sync(verbose: bool = False, watch: bool = False, console_status: b
     logger.info(
         "Sync command started",
         project=config.project,
-        watch_mode=watch,
         verbose=verbose,
         directory=str(config.home),
     )
 
-    sync_service = await get_sync_service()
+    sync_service = await get_sync_service(project)
 
-    # Start watching if requested
-    if watch:
-        logger.info("Starting watch service after initial sync")
-        watch_service = WatchService(
-            sync_service=sync_service,
-            file_service=sync_service.entity_service.file_service,
-            config=config,
-        )
+    logger.info("Running one-time sync")
+    knowledge_changes = await sync_service.sync(config.home)
 
-        # full sync - no progress bars in watch mode
-        await sync_service.sync(config.home)
+    # Log results
+    duration_ms = int((time.time() - start_time) * 1000)
+    logger.info(
+        "Sync command completed",
+        project=config.project,
+        total_changes=knowledge_changes.total,
+        new_files=len(knowledge_changes.new),
+        modified_files=len(knowledge_changes.modified),
+        deleted_files=len(knowledge_changes.deleted),
+        moved_files=len(knowledge_changes.moves),
+        duration_ms=duration_ms,
+    )
 
-        # watch changes
-        await watch_service.run()  # pragma: no cover
+    # Display results
+    if verbose:
+        display_detailed_sync_results(knowledge_changes)
     else:
-        # one time sync
-        logger.info("Running one-time sync")
-        knowledge_changes = await sync_service.sync(config.home)
-
-        # Log results
-        duration_ms = int((time.time() - start_time) * 1000)
-        logger.info(
-            "Sync command completed",
-            project=config.project,
-            total_changes=knowledge_changes.total,
-            new_files=len(knowledge_changes.new),
-            modified_files=len(knowledge_changes.modified),
-            deleted_files=len(knowledge_changes.deleted),
-            moved_files=len(knowledge_changes.moves),
-            duration_ms=duration_ms,
-        )
-
-        # Display results
-        if verbose:
-            display_detailed_sync_results(knowledge_changes)
-        else:
-            display_sync_summary(knowledge_changes)  # pragma: no cover
+        display_sync_summary(knowledge_changes)  # pragma: no cover
 
 
 @app.command()
@@ -216,22 +210,15 @@ def sync(
         "-v",
         help="Show detailed sync information.",
     ),
-    watch: bool = typer.Option(
-        False,
-        "--watch",
-        "-w",
-        help="Start watching for changes after sync.",
-    ),
 ) -> None:
     """Sync knowledge files with the database."""
     try:
         # Show which project we're syncing
-        if not watch:  # Don't show in watch mode as it would break the UI
-            typer.echo(f"Syncing project: {config.project}")
-            typer.echo(f"Project path: {config.home}")
+        typer.echo(f"Syncing project: {config.project}")
+        typer.echo(f"Project path: {config.home}")
 
         # Run sync
-        asyncio.run(run_sync(verbose=verbose, watch=watch))
+        asyncio.run(run_sync(verbose=verbose))
 
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
@@ -240,7 +227,6 @@ def sync(
                 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)

basic_memory/cli/main.py

@@ -4,6 +4,7 @@ from basic_memory.cli.app import app  # pragma: no cover
 
 # Register commands
 from basic_memory.cli.commands import (  # noqa: F401  # pragma: no cover
+    auth,
     db,
     import_chatgpt,
     import_claude_conversations,
@@ -15,12 +16,7 @@ from basic_memory.cli.commands import (  # noqa: F401  # pragma: no cover
     sync,
     tool,
 )
-from basic_memory.config import config
-from basic_memory.services.initialization import ensure_initialization
 
 if __name__ == "__main__":  # pragma: no cover
-    # Run initialization if we are starting as a module
-    ensure_initialization(config)
-
     # start the app
     app()

basic_memory/config.py

@@ -2,76 +2,49 @@
 
 import json
 import os
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Dict, Literal, Optional
+from typing import Any, Dict, Literal, Optional, List
 
 from loguru import logger
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
+from setuptools.command.setopt import config_file
 
 import basic_memory
-from basic_memory.utils import setup_logging
+from basic_memory.utils import setup_logging, generate_permalink
+
 
 DATABASE_NAME = "memory.db"
+APP_DATABASE_NAME = "memory.db"  # Using the same name but in the app directory
 DATA_DIR_NAME = ".basic-memory"
 CONFIG_FILE_NAME = "config.json"
+WATCH_STATUS_JSON = "watch-status.json"
 
 Environment = Literal["test", "dev", "user"]
 
 
-class ProjectConfig(BaseSettings):
+@dataclass
+class ProjectConfig:
     """Configuration for a specific basic-memory project."""
 
-    env: Environment = Field(default="dev", description="Environment name")
-
-    # Default to ~/basic-memory but allow override with env var: BASIC_MEMORY_HOME
-    home: Path = Field(
-        default_factory=lambda: Path.home() / "basic-memory",
-        description="Base path for basic-memory files",
-    )
-
-    # Name of the project
-    project: str = Field(default="default", description="Project name")
-
-    # Watch service configuration
-    sync_delay: int = Field(
-        default=1000, description="Milliseconds to wait after changes before syncing", gt=0
-    )
-
-    # update permalinks on move
-    update_permalinks_on_move: bool = Field(
-        default=False,
-        description="Whether to update permalinks when files are moved or renamed. default (False)",
-    )
-
-    model_config = SettingsConfigDict(
-        env_prefix="BASIC_MEMORY_",
-        extra="ignore",
-        env_file=".env",
-        env_file_encoding="utf-8",
-    )
+    name: str
+    home: Path
 
     @property
-    def database_path(self) -> Path:
-        """Get SQLite database path."""
-        database_path = self.home / DATA_DIR_NAME / DATABASE_NAME
-        if not database_path.exists():
-            database_path.parent.mkdir(parents=True, exist_ok=True)
-            database_path.touch()
-        return database_path
+    def project(self):
+        return self.name
 
-    @field_validator("home")
-    @classmethod
-    def ensure_path_exists(cls, v: Path) -> Path:  # pragma: no cover
-        """Ensure project path exists."""
-        if not v.exists():
-            v.mkdir(parents=True)
-        return v
+    @property
+    def project_url(self) -> str:  # pragma: no cover
+        return f"/{generate_permalink(self.name)}"
 
 
 class BasicMemoryConfig(BaseSettings):
     """Pydantic model for Basic Memory global configuration."""
 
+    env: Environment = Field(default="dev", description="Environment name")
+
     projects: Dict[str, str] = Field(
         default_factory=lambda: {"main": str(Path.home() / "basic-memory")},
         description="Mapping of project names to their filesystem paths",
@@ -81,8 +54,15 @@ class BasicMemoryConfig(BaseSettings):
         description="Name of the default project to use",
     )
 
+    # overridden by ~/.basic-memory/config.json
     log_level: str = "INFO"
 
+    # Watch service configuration
+    sync_delay: int = Field(
+        default=1000, description="Milliseconds to wait after changes before syncing", gt=0
+    )
+
+    # update permalinks on move
     update_permalinks_on_move: bool = Field(
         default=False,
         description="Whether to update permalinks when files are moved or renamed. default (False)",
@@ -96,25 +76,84 @@ class BasicMemoryConfig(BaseSettings):
     model_config = SettingsConfigDict(
         env_prefix="BASIC_MEMORY_",
         extra="ignore",
+        env_file=".env",
+        env_file_encoding="utf-8",
     )
 
+    def get_project_path(self, project_name: Optional[str] = None) -> Path:  # pragma: no cover
+        """Get the path for a specific project or the default project."""
+        name = project_name or self.default_project
+
+        if name not in self.projects:
+            raise ValueError(f"Project '{name}' not found in configuration")
+
+        return Path(self.projects[name])
+
     def model_post_init(self, __context: Any) -> None:
         """Ensure configuration is valid after initialization."""
         # Ensure main project exists
-        if "main" not in self.projects:
+        if "main" not in self.projects:  # pragma: no cover
             self.projects["main"] = str(Path.home() / "basic-memory")
 
         # Ensure default project is valid
-        if self.default_project not in self.projects:
+        if self.default_project not in self.projects:  # pragma: no cover
             self.default_project = "main"
 
+    @property
+    def app_database_path(self) -> Path:
+        """Get the path to the app-level database.
+
+        This is the single database that will store all knowledge data
+        across all projects.
+        """
+        database_path = Path.home() / DATA_DIR_NAME / APP_DATABASE_NAME
+        if not database_path.exists():  # pragma: no cover
+            database_path.parent.mkdir(parents=True, exist_ok=True)
+            database_path.touch()
+        return database_path
+
+    @property
+    def database_path(self) -> Path:
+        """Get SQLite database path.
+
+        Rreturns the app-level database path
+        for backward compatibility in the codebase.
+        """
+
+        # Load the app-level database path from the global config
+        config = config_manager.load_config()  # pragma: no cover
+        return config.app_database_path  # pragma: no cover
+
+    @property
+    def project_list(self) -> List[ProjectConfig]:  # pragma: no cover
+        """Get all configured projects as ProjectConfig objects."""
+        return [ProjectConfig(name=name, home=Path(path)) for name, path in self.projects.items()]
+
+    @field_validator("projects")
+    @classmethod
+    def ensure_project_paths_exists(cls, v: Dict[str, str]) -> Dict[str, str]:  # pragma: no cover
+        """Ensure project path exists."""
+        for name, path_value in v.items():
+            path = Path(path_value)
+            if not Path(path).exists():
+                try:
+                    path.mkdir(parents=True)
+                except Exception as e:
+                    logger.error(f"Failed to create project path: {e}")
+                    raise e
+        return v
+
 
 class ConfigManager:
     """Manages Basic Memory configuration."""
 
     def __init__(self) -> None:
         """Initialize the configuration manager."""
-        self.config_dir = Path.home() / DATA_DIR_NAME
+        home = os.getenv("HOME", Path.home())
+        if isinstance(home, str):
+            home = Path(home)
+
+        self.config_dir = home / DATA_DIR_NAME
         self.config_file = self.config_dir / CONFIG_FILE_NAME
 
         # Ensure config directory exists
@@ -129,7 +168,7 @@ class ConfigManager:
             try:
                 data = json.loads(self.config_file.read_text(encoding="utf-8"))
                 return BasicMemoryConfig(**data)
-            except Exception as e:
+            except Exception as e:  # pragma: no cover
                 logger.error(f"Failed to load config: {e}")
                 config = BasicMemoryConfig()
                 self.save_config(config)
@@ -141,7 +180,7 @@ class ConfigManager:
 
     def save_config(self, config: BasicMemoryConfig) -> None:
         """Save configuration to file."""
-        try:
+        try:            
             self.config_file.write_text(json.dumps(config.model_dump(), indent=2))
         except Exception as e:  # pragma: no cover
             logger.error(f"Failed to save config: {e}")
@@ -156,37 +195,25 @@ class ConfigManager:
         """Get the default project name."""
         return self.config.default_project
 
-    def get_project_path(self, project_name: Optional[str] = None) -> Path:
-        """Get the path for a specific project or the default project."""
-        name = project_name or self.config.default_project
-
-        # Check if specified in environment variable
-        if not project_name and "BASIC_MEMORY_PROJECT" in os.environ:
-            name = os.environ["BASIC_MEMORY_PROJECT"]
-
-        if name not in self.config.projects:
-            raise ValueError(f"Project '{name}' not found in configuration")
-
-        return Path(self.config.projects[name])
-
-    def add_project(self, name: str, path: str) -> None:
+    def add_project(self, name: str, path: str) -> ProjectConfig:
         """Add a new project to the configuration."""
-        if name in self.config.projects:
+        if name in self.config.projects:  # pragma: no cover
             raise ValueError(f"Project '{name}' already exists")
 
         # Ensure the path exists
         project_path = Path(path)
-        project_path.mkdir(parents=True, exist_ok=True)
+        project_path.mkdir(parents=True, exist_ok=True)  # pragma: no cover
 
         self.config.projects[name] = str(project_path)
         self.save_config(self.config)
+        return ProjectConfig(name=name, home=project_path)
 
     def remove_project(self, name: str) -> None:
         """Remove a project from the configuration."""
-        if name not in self.config.projects:
+        if name not in self.config.projects:  # pragma: no cover
             raise ValueError(f"Project '{name}' not found")
 
-        if name == self.config.default_project:
+        if name == self.config.default_project:  # pragma: no cover
             raise ValueError(f"Cannot remove the default project '{name}'")
 
         del self.config.projects[name]
@@ -202,33 +229,59 @@ class ConfigManager:
 
 
 def get_project_config(project_name: Optional[str] = None) -> ProjectConfig:
-    """Get a project configuration for the specified project."""
-    config_manager = ConfigManager()
+    """
+    Get the project configuration for the current session.
+    If project_name is provided, it will be used instead of the default project.
+    """
 
-    # Get project name from environment variable or use provided name or default
-    actual_project_name = os.environ.get(
-        "BASIC_MEMORY_PROJECT", project_name or config_manager.default_project
-    )
+    actual_project_name = None
 
-    update_permalinks_on_move = config_manager.load_config().update_permalinks_on_move
-    try:
-        project_path = config_manager.get_project_path(actual_project_name)
-        return ProjectConfig(
-            home=project_path,
-            project=actual_project_name,
-            update_permalinks_on_move=update_permalinks_on_move,
+    # load the config from file
+    global app_config
+    app_config = config_manager.load_config()
+
+    # Get project name from environment variable
+    os_project_name = os.environ.get("BASIC_MEMORY_PROJECT", None)
+    if os_project_name:  # pragma: no cover
+        logger.warning(
+            f"BASIC_MEMORY_PROJECT is not supported anymore. Use the --project flag or set the default project in the config instead. Setting default project to {os_project_name}"
         )
-    except ValueError:  # pragma: no cover
-        logger.warning(f"Project '{actual_project_name}' not found, using default")
-        project_path = config_manager.get_project_path(config_manager.default_project)
-        return ProjectConfig(home=project_path, project=config_manager.default_project)
+        actual_project_name = project_name
+    # if the project_name is passed in, use it
+    elif not project_name:
+        # use default
+        actual_project_name = app_config.default_project
+    else:  # pragma: no cover
+        actual_project_name = project_name
+
+    # the config contains a dict[str,str] of project names and absolute paths
+    assert actual_project_name is not None, "actual_project_name cannot be None"
+
+    project_path = app_config.projects.get(actual_project_name)
+    if not project_path:  # pragma: no cover
+        raise ValueError(f"Project '{actual_project_name}' not found")
+
+    return ProjectConfig(name=actual_project_name, home=Path(project_path))
 
 
 # Create config manager
 config_manager = ConfigManager()
 
-# Load project config for current context
-config = get_project_config()
+# Export the app-level config
+app_config: BasicMemoryConfig = config_manager.config
+
+# Load project config for the default project (backward compatibility)
+config: ProjectConfig = get_project_config()
+
+
+def update_current_project(project_name: str) -> None:
+    """Update the global config to use a different project.
+
+    This is used by the CLI when --project flag is specified.
+    """
+    global config
+    config = get_project_config(project_name)  # pragma: no cover
+
 
 # setup logging to a single log file in user home directory
 user_home = Path.home()
@@ -236,6 +289,7 @@ log_dir = user_home / DATA_DIR_NAME
 log_dir.mkdir(parents=True, exist_ok=True)
 
 
+# Process info for logging
 def get_process_name():  # pragma: no cover
     """
     get the type of process for logging
@@ -258,6 +312,9 @@ process_name = get_process_name()
 _LOGGING_SETUP = False
 
 
+# Logging
+
+
 def setup_basic_memory_logging():  # pragma: no cover
     """Set up logging for basic-memory, ensuring it only happens once."""
     global _LOGGING_SETUP
@@ -267,7 +324,7 @@ def setup_basic_memory_logging():  # pragma: no cover
         return
 
     setup_logging(
-        env=config.env,
+        env=config_manager.config.env,
         home_dir=user_home,  # Use user home for logs
         log_level=config_manager.load_config().log_level,
         log_file=f"{DATA_DIR_NAME}/basic-memory-{process_name}.log",

basic_memory/db.py

@@ -4,8 +4,7 @@ from enum import Enum, auto
 from pathlib import Path
 from typing import AsyncGenerator, Optional
 
-
-from basic_memory.config import ProjectConfig
+from basic_memory.config import BasicMemoryConfig
 from alembic import command
 from alembic.config import Config
 
@@ -147,7 +146,7 @@ async def engine_session_factory(
 
 
 async def run_migrations(
-    app_config: ProjectConfig, database_type=DatabaseType.FILESYSTEM
+    app_config: BasicMemoryConfig, database_type=DatabaseType.FILESYSTEM
 ):  # pragma: no cover
     """Run any pending alembic migrations."""
     logger.info("Running database migrations...")
@@ -172,7 +171,10 @@ async def run_migrations(
         logger.info("Migrations completed successfully")
 
         _, session_maker = await get_or_create_db(app_config.database_path, database_type)
-        await SearchRepository(session_maker).init_search_index()
+
+        # initialize the search Index schema
+        # the project_id is not used for init_search_index, so we pass a dummy value
+        await SearchRepository(session_maker, 1).init_search_index()
     except Exception as e:  # pragma: no cover
         logger.error(f"Error running migrations: {e}")
         raise