basic-memory 0.8.0__py3-none-any.whl → 0.10.0__py3-none-any.whl

basic_memory/config.py

@@ -1,17 +1,19 @@
 """Configuration management for basic-memory."""
 
+import json
+import os
 from pathlib import Path
-from typing import Literal
+from typing import Any, Dict, Literal, Optional
 
+import basic_memory
+from basic_memory.utils import setup_logging
 from loguru import logger
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
-import basic_memory
-from basic_memory.utils import setup_logging
-
 DATABASE_NAME = "memory.db"
 DATA_DIR_NAME = ".basic-memory"
+CONFIG_FILE_NAME = "config.json"
 
 Environment = Literal["test", "dev", "user"]
 
@@ -62,15 +64,160 @@ class ProjectConfig(BaseSettings):
         return v
 
 
-# Load project config
-config = ProjectConfig()
+class BasicMemoryConfig(BaseSettings):
+    """Pydantic model for Basic Memory global configuration."""
+
+    projects: Dict[str, str] = Field(
+        default_factory=lambda: {"main": str(Path.home() / "basic-memory")},
+        description="Mapping of project names to their filesystem paths",
+    )
+    default_project: str = Field(
+        default="main",
+        description="Name of the default project to use",
+    )
+
+    model_config = SettingsConfigDict(
+        env_prefix="BASIC_MEMORY_",
+        extra="ignore",
+    )
+
+    def model_post_init(self, __context: Any) -> None:
+        """Ensure configuration is valid after initialization."""
+        # Ensure main project exists
+        if "main" not in self.projects:
+            self.projects["main"] = str(Path.home() / "basic-memory")
+
+        # Ensure default project is valid
+        if self.default_project not in self.projects:
+            self.default_project = "main"
+
+
+class ConfigManager:
+    """Manages Basic Memory configuration."""
+
+    def __init__(self) -> None:
+        """Initialize the configuration manager."""
+        self.config_dir = Path.home() / DATA_DIR_NAME
+        self.config_file = self.config_dir / CONFIG_FILE_NAME
+
+        # Ensure config directory exists
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        # Load or create configuration
+        self.config = self.load_config()
+
+    def load_config(self) -> BasicMemoryConfig:
+        """Load configuration from file or create default."""
+        if self.config_file.exists():
+            try:
+                data = json.loads(self.config_file.read_text(encoding="utf-8"))
+                return BasicMemoryConfig(**data)
+            except Exception as e:
+                logger.error(f"Failed to load config: {e}")
+                config = BasicMemoryConfig()
+                self.save_config(config)
+                return config
+        else:
+            config = BasicMemoryConfig()
+            self.save_config(config)
+            return config
+
+    def save_config(self, config: BasicMemoryConfig) -> None:
+        """Save configuration to file."""
+        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}")
+
+    @property
+    def projects(self) -> Dict[str, str]:
+        """Get all configured projects."""
+        return self.config.projects.copy()
+
+    @property
+    def default_project(self) -> str:
+        """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:
+        """Add a new project to the configuration."""
+        if name in self.config.projects:
+            raise ValueError(f"Project '{name}' already exists")
+
+        # Ensure the path exists
+        project_path = Path(path)
+        project_path.mkdir(parents=True, exist_ok=True)
+
+        self.config.projects[name] = str(project_path)
+        self.save_config(self.config)
+
+    def remove_project(self, name: str) -> None:
+        """Remove a project from the configuration."""
+        if name not in self.config.projects:
+            raise ValueError(f"Project '{name}' not found")
+
+        if name == self.config.default_project:
+            raise ValueError(f"Cannot remove the default project '{name}'")
+
+        del self.config.projects[name]
+        self.save_config(self.config)
+
+    def set_default_project(self, name: str) -> None:
+        """Set the default project."""
+        if name not in self.config.projects:  # pragma: no cover
+            raise ValueError(f"Project '{name}' not found")
+
+        self.config.default_project = name
+        self.save_config(self.config)
+
+
+def get_project_config(project_name: Optional[str] = None) -> ProjectConfig:
+    """Get a project configuration for the specified project."""
+    config_manager = ConfigManager()
+
+    # 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
+    )
+
+    try:
+        project_path = config_manager.get_project_path(actual_project_name)
+        return ProjectConfig(home=project_path, project=actual_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)
+
+
+# Create config manager
+config_manager = ConfigManager()
+
+# Load project config for current context
+config = get_project_config()
+
+# setup logging to a single log file in user home directory
+user_home = Path.home()
+log_dir = user_home / DATA_DIR_NAME
+log_dir.mkdir(parents=True, exist_ok=True)
 
-# setup logging
 setup_logging(
     env=config.env,
-    home_dir=config.home,
+    home_dir=user_home,  # Use user home for logs
     log_level=config.log_level,
-    log_file=".basic-memory/basic-memory.log",
+    log_file=f"{DATA_DIR_NAME}/basic-memory.log",
     console=False,
 )
-logger.info(f"Starting Basic Memory {basic_memory.__version__}")
+logger.info(f"Starting Basic Memory {basic_memory.__version__} (Project: {config.project})")

basic_memory/db.py

@@ -86,8 +86,16 @@ async def get_or_create_db(
         _engine = create_async_engine(db_url, connect_args={"check_same_thread": False})
         _session_maker = async_sessionmaker(_engine, expire_on_commit=False)
 
-    assert _engine is not None  # for type checker
-    assert _session_maker is not None  # for type checker
+    # These checks should never fail since we just created the engine and session maker
+    # if they were None, but we'll check anyway for the type checker
+    if _engine is None:
+        logger.error("Failed to create database engine", db_path=str(db_path))
+        raise RuntimeError("Database engine initialization failed")
+
+    if _session_maker is None:
+        logger.error("Failed to create session maker", db_path=str(db_path))
+        raise RuntimeError("Session maker initialization failed")
+
     return _engine, _session_maker
 
 
@@ -121,8 +129,15 @@ async def engine_session_factory(
     try:
         _session_maker = async_sessionmaker(_engine, expire_on_commit=False)
 
-        assert _engine is not None  # for type checker
-        assert _session_maker is not None  # for type checker
+        # Verify that engine and session maker are initialized
+        if _engine is None:  # pragma: no cover
+            logger.error("Database engine is None in engine_session_factory")
+            raise RuntimeError("Database engine initialization failed")
+
+        if _session_maker is None:  # pragma: no cover
+            logger.error("Session maker is None in engine_session_factory")
+            raise RuntimeError("Session maker initialization failed")
+
         yield _engine, _session_maker
     finally:
         if _engine:

basic_memory/deps.py

@@ -2,7 +2,6 @@
 
 from typing import Annotated
 
-import logfire
 from fastapi import Depends
 from sqlalchemy.ext.asyncio import (
     AsyncSession,
@@ -16,6 +15,7 @@ from basic_memory.markdown import EntityParser
 from basic_memory.markdown.markdown_processor import MarkdownProcessor
 from basic_memory.repository.entity_repository import EntityRepository
 from basic_memory.repository.observation_repository import ObservationRepository
+from basic_memory.repository.project_info_repository import ProjectInfoRepository
 from basic_memory.repository.relation_repository import RelationRepository
 from basic_memory.repository.search_repository import SearchRepository
 from basic_memory.services import (
@@ -45,8 +45,6 @@ async def get_engine_factory(
 ) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:  # pragma: no cover
     """Get engine and session maker."""
     engine, session_maker = await db.get_or_create_db(project_config.database_path)
-    if project_config.env != "test":
-        logfire.instrument_sqlalchemy(engine=engine)
     return engine, session_maker
 
 
@@ -107,6 +105,15 @@ async def get_search_repository(
 SearchRepositoryDep = Annotated[SearchRepository, Depends(get_search_repository)]
 
 
+def get_project_info_repository(
+    session_maker: SessionMakerDep,
+):
+    """Dependency for StatsRepository."""
+    return ProjectInfoRepository(session_maker)
+
+
+ProjectInfoRepositoryDep = Annotated[ProjectInfoRepository, Depends(get_project_info_repository)]
+
 ## services
 
 

basic_memory/file_utils.py

@@ -2,11 +2,13 @@
 
 import hashlib
 from pathlib import Path
-from typing import Dict, Any, Union
+from typing import Any, Dict, Union
 
 import yaml
 from loguru import logger
 
+from basic_memory.utils import FilePath
+
 
 class FileError(Exception):
     """Base exception for file operations."""
@@ -48,42 +50,47 @@ async def compute_checksum(content: Union[str, bytes]) -> str:
         raise FileError(f"Failed to compute checksum: {e}")
 
 
-async def ensure_directory(path: Path) -> None:
+async def ensure_directory(path: FilePath) -> None:
     """
     Ensure directory exists, creating if necessary.
 
     Args:
-        path: Directory path to ensure
+        path: Directory path to ensure (Path or string)
 
     Raises:
         FileWriteError: If directory creation fails
     """
     try:
-        path.mkdir(parents=True, exist_ok=True)
+        # Convert string to Path if needed
+        path_obj = Path(path) if isinstance(path, str) else path
+        path_obj.mkdir(parents=True, exist_ok=True)
     except Exception as e:  # pragma: no cover
-        logger.error(f"Failed to create directory: {path}: {e}")
+        logger.error("Failed to create directory", path=str(path), error=str(e))
         raise FileWriteError(f"Failed to create directory {path}: {e}")
 
 
-async def write_file_atomic(path: Path, content: str) -> None:
+async def write_file_atomic(path: FilePath, content: str) -> None:
     """
     Write file with atomic operation using temporary file.
 
     Args:
-        path: Target file path
+        path: Target file path (Path or string)
         content: Content to write
 
     Raises:
         FileWriteError: If write operation fails
     """
-    temp_path = path.with_suffix(".tmp")
+    # Convert string to Path if needed
+    path_obj = Path(path) if isinstance(path, str) else path
+    temp_path = path_obj.with_suffix(".tmp")
+
     try:
-        temp_path.write_text(content)
-        temp_path.replace(path)
-        logger.debug(f"wrote file: {path}")
+        temp_path.write_text(content, encoding="utf-8")
+        temp_path.replace(path_obj)
+        logger.debug("Wrote file atomically", path=str(path_obj), content_length=len(content))
     except Exception as e:  # pragma: no cover
         temp_path.unlink(missing_ok=True)
-        logger.error(f"Failed to write file: {path}: {e}")
+        logger.error("Failed to write file", path=str(path_obj), error=str(e))
         raise FileWriteError(f"Failed to write file {path}: {e}")
 
 
@@ -173,7 +180,7 @@ def remove_frontmatter(content: str) -> str:
     return parts[2].strip()
 
 
-async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
+async def update_frontmatter(path: FilePath, updates: Dict[str, Any]) -> str:
     """Update frontmatter fields in a file while preserving all content.
 
     Only modifies the frontmatter section, leaving all content untouched.
@@ -181,7 +188,7 @@ async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
     Returns checksum of updated file.
 
     Args:
-        path: Path to markdown file
+        path: Path to markdown file (Path or string)
         updates: Dict of frontmatter fields to update
 
     Returns:
@@ -192,8 +199,11 @@ async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
         ParseError: If frontmatter parsing fails
     """
     try:
+        # Convert string to Path if needed
+        path_obj = Path(path) if isinstance(path, str) else path
+
         # Read current content
-        content = path.read_text()
+        content = path_obj.read_text(encoding="utf-8")
 
         # Parse current frontmatter
         current_fm = {}
@@ -205,12 +215,18 @@ async def update_frontmatter(path: Path, updates: Dict[str, Any]) -> str:
         new_fm = {**current_fm, **updates}
 
         # Write new file with updated frontmatter
-        yaml_fm = yaml.dump(new_fm, sort_keys=False)
+        yaml_fm = yaml.dump(new_fm, sort_keys=False, allow_unicode=True)
         final_content = f"---\n{yaml_fm}---\n\n{content.strip()}"
 
-        await write_file_atomic(path, final_content)
+        logger.debug("Updating frontmatter", path=str(path_obj), update_keys=list(updates.keys()))
+
+        await write_file_atomic(path_obj, final_content)
         return await compute_checksum(final_content)
 
     except Exception as e:  # pragma: no cover
-        logger.error(f"Failed to update frontmatter in {path}: {e}")
+        logger.error(
+            "Failed to update frontmatter",
+            path=str(path) if isinstance(path, (str, Path)) else "<unknown>",
+            error=str(e),
+        )
         raise FileError(f"Failed to update frontmatter: {e}")

basic_memory/markdown/markdown_processor.py

@@ -83,7 +83,7 @@ class MarkdownProcessor:
         """
         # Dirty check if needed
         if expected_checksum is not None:
-            current_content = path.read_text()
+            current_content = path.read_text(encoding="utf-8")
             current_checksum = await file_utils.compute_checksum(current_content)
             if current_checksum != expected_checksum:
                 raise DirtyFileError(f"File {path} has been modified")

basic_memory/markdown/utils.py

@@ -5,6 +5,7 @@ from typing import Optional, Any
 
 from frontmatter import Post
 
+from basic_memory.file_utils import has_frontmatter, remove_frontmatter
 from basic_memory.markdown import EntityMarkdown
 from basic_memory.models import Entity, Observation as ObservationModel
 from basic_memory.utils import generate_permalink
@@ -78,6 +79,10 @@ async def schema_to_markdown(schema: Any) -> Post:
     content = schema.content or ""
     frontmatter_metadata = dict(schema.entity_metadata or {})
 
+    # if the content contains frontmatter, remove it and merge
+    if has_frontmatter(content):
+        content = remove_frontmatter(content)
+
     # Remove special fields for ordered frontmatter
     for field in ["type", "title", "permalink"]:
         frontmatter_metadata.pop(field, None)

basic_memory/mcp/main.py

@@ -17,9 +17,8 @@ import basic_memory.mcp.tools  # noqa: F401 # pragma: no cover
 import basic_memory.mcp.prompts  # noqa: F401 # pragma: no cover
 
 
-
 if __name__ == "__main__":  # pragma: no cover
     home_dir = config.home
     logger.info("Starting Basic Memory MCP server")
     logger.info(f"Home directory: {home_dir}")
-    mcp.run()
+    mcp.run()

basic_memory/mcp/prompts/__init__.py

@@ -10,6 +10,10 @@ from basic_memory.mcp.prompts import continue_conversation
 from basic_memory.mcp.prompts import recent_activity
 from basic_memory.mcp.prompts import search
 from basic_memory.mcp.prompts import ai_assistant_guide
-from basic_memory.mcp.prompts import json_canvas_spec
 
-__all__ = ["ai_assistant_guide", "continue_conversation", "json_canvas_spec", "recent_activity", "search"]
+__all__ = [
+    "ai_assistant_guide",
+    "continue_conversation",
+    "recent_activity",
+    "search",
+]

basic_memory/mcp/prompts/ai_assistant_guide.py

@@ -1,14 +1,12 @@
 from pathlib import Path
 
-import logfire
-from loguru import logger
-
 from basic_memory.mcp.server import mcp
+from loguru import logger
 
 
 @mcp.resource(
     uri="memory://ai_assistant_guide",
-    name="ai_assistant_guide",
+    name="ai assistant guide",
     description="Give an AI assistant guidance on how to use Basic Memory tools effectively",
 )
 def ai_assistant_guide() -> str:
@@ -20,9 +18,10 @@ def ai_assistant_guide() -> str:
     Returns:
         A focused guide on Basic Memory usage.
     """
-    with logfire.span("Getting Basic Memory guide"):  # pyright: ignore
-        logger.info("Loading AI assistant guide resource")
-        guide_doc = Path(__file__).parent.parent.parent.parent.parent / "data/ai_assistant_guide.md"
-        content = guide_doc.read_text()
-        logger.info(f"Loaded AI assistant guide ({len(content)} chars)")
-        return content
+    logger.info("Loading AI assistant guide resource")
+    guide_doc = (
+        Path(__file__).parent.parent.parent.parent.parent / "static" / "ai_assistant_guide.md"
+    )
+    content = guide_doc.read_text(encoding="utf-8")
+    logger.info(f"Loaded AI assistant guide ({len(content)} chars)")
+    return content