basic-memory 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

basic_memory/cli/commands/import_memory_json.py

@@ -19,13 +19,16 @@ from basic_memory.markdown.schemas import EntityMarkdown, EntityFrontmatter, Obs
 
 console = Console()
 
-async def process_memory_json(json_path: Path, base_path: Path,markdown_processor: MarkdownProcessor):
+
+async def process_memory_json(
+    json_path: Path, base_path: Path, markdown_processor: MarkdownProcessor
+):
     """Import entities from memory.json using markdown processor."""
-    
+
     # First pass - collect all relations by source entity
     entity_relations: Dict[str, List[Relation]] = {}
     entities: Dict[str, Dict[str, Any]] = {}
-    
+
     with Progress(
         SpinnerColumn(),
         TextColumn("[progress.description]{task.description}"),
@@ -34,12 +37,12 @@ async def process_memory_json(json_path: Path, base_path: Path,markdown_processo
         console=console,
     ) as progress:
         read_task = progress.add_task("Reading memory.json...", total=None)
-        
+
         # First pass - collect entities and relations
         with open(json_path) as f:
             lines = f.readlines()
             progress.update(read_task, total=len(lines))
-            
+
             for line in lines:
                 data = json.loads(line)
                 if data["type"] == "entity":
@@ -52,14 +55,14 @@ async def process_memory_json(json_path: Path, base_path: Path,markdown_processo
                     entity_relations[source].append(
                         Relation(
                             type=data.get("relationType") or data.get("relation_type"),
-                            target=data.get("to") or data.get("to_id")
+                            target=data.get("to") or data.get("to_id"),
                         )
                     )
                 progress.update(read_task, advance=1)
 
         # Second pass - create and write entities
         write_task = progress.add_task("Creating entities...", total=len(entities))
-        
+
         entities_created = 0
         for name, entity_data in entities.items():
             entity = EntityMarkdown(
@@ -67,26 +70,25 @@ async def process_memory_json(json_path: Path, base_path: Path,markdown_processo
                     metadata={
                         "type": entity_data["entityType"],
                         "title": name,
-                        "permalink": f"{entity_data['entityType']}/{name}"
+                        "permalink": f"{entity_data['entityType']}/{name}",
                     }
                 ),
                 content=f"# {name}\n",
-                observations=[
-                    Observation(content=obs) 
-                    for obs in entity_data["observations"]
-                ],
-                relations=entity_relations.get(name, [])  # Add any relations where this entity is the source
+                observations=[Observation(content=obs) for obs in entity_data["observations"]],
+                relations=entity_relations.get(
+                    name, []
+                ),  # Add any relations where this entity is the source
             )
-            
+
             # Let markdown processor handle writing
             file_path = base_path / f"{entity_data['entityType']}/{name}.md"
             await markdown_processor.write_file(file_path, entity)
             entities_created += 1
             progress.update(write_task, advance=1)
-    
+
     return {
         "entities": entities_created,
-        "relations": sum(len(rels) for rels in entity_relations.values())
+        "relations": sum(len(rels) for rels in entity_relations.values()),
     }
 
 
@@ -101,39 +103,41 @@ def import_json(
     json_path: Path = typer.Argument(..., help="Path to memory.json file to import"),
 ):
     """Import entities and relations from a memory.json file.
-    
+
     This command will:
     1. Read entities and relations from the JSON file
     2. Create markdown files for each entity
     3. Include outgoing relations in each entity's markdown
-    
+
     After importing, run 'basic-memory sync' to index the new files.
     """
-    
+
     if not json_path.exists():
         typer.echo(f"Error: File not found: {json_path}", err=True)
         raise typer.Exit(1)
-        
+
     try:
         # Get markdown processor
         markdown_processor = asyncio.run(get_markdown_processor())
-        
+
         # Process the file
         base_path = config.home
         console.print(f"\nImporting from {json_path}...writing to {base_path}")
         results = asyncio.run(process_memory_json(json_path, base_path, markdown_processor))
-        
+
         # Show results
-        console.print(Panel(
-            f"[green]Import complete![/green]\n\n"
-            f"Created {results['entities']} entities\n"
-            f"Added {results['relations']} relations",
-            expand=False
-        ))
-        
+        console.print(
+            Panel(
+                f"[green]Import complete![/green]\n\n"
+                f"Created {results['entities']} entities\n"
+                f"Added {results['relations']} relations",
+                expand=False,
+            )
+        )
+
         console.print("\nRun 'basic-memory sync' to index the new files.")
-        
+
     except Exception as e:
         logger.exception("Import failed")
         typer.echo(f"Error during import: {e}", err=True)
-        raise typer.Exit(1)
+        raise typer.Exit(1)

basic_memory/cli/commands/mcp.py

@@ -0,0 +1,20 @@
+"""MCP server command."""
+
+from loguru import logger
+from basic_memory.cli.app import app
+from basic_memory.config import config
+
+# Import mcp instance
+from basic_memory.mcp.server import mcp as mcp_server  # pragma: no cover
+
+# Import mcp tools to register them
+import basic_memory.mcp.tools  # noqa: F401  # pragma: no cover
+
+
+@app.command()
+def mcp():
+    """Run the MCP server for Claude Desktop integration."""
+    home_dir = config.home
+    logger.info("Starting Basic Memory MCP server")
+    logger.info(f"Home directory: {home_dir}")
+    mcp_server.run()

basic_memory/cli/commands/status.py

@@ -21,7 +21,9 @@ from basic_memory.sync.utils import SyncReport
 console = Console()
 
 
-async def get_file_change_scanner(db_type=DatabaseType.FILESYSTEM) -> FileChangeScanner:
+async def get_file_change_scanner(
+    db_type=DatabaseType.FILESYSTEM,
+) -> FileChangeScanner:  # pragma: no cover
     """Get sync service instance."""
     async with db.engine_session_factory(db_path=config.database_path, db_type=db_type) as (
         engine,
@@ -32,7 +34,9 @@ async def get_file_change_scanner(db_type=DatabaseType.FILESYSTEM) -> FileChange
         return file_change_scanner
 
 
-def add_files_to_tree(tree: Tree, paths: Set[str], style: str, checksums: Dict[str, str] = None):
+def add_files_to_tree(
+    tree: Tree, paths: Set[str], style: str, checksums: Dict[str, str] | None = None
+):
     """Add files to tree, grouped by directory."""
     # Group by directory
     by_dir = {}
@@ -126,7 +130,8 @@ def display_changes(title: str, changes: SyncReport, verbose: bool = False):
         by_dir = group_changes_by_directory(changes)
         for dir_name, counts in sorted(by_dir.items()):
             summary = build_directory_summary(counts)
-            tree.add(f"[bold]{dir_name}/[/bold] {summary}")
+            if summary:  # Only show directories with changes
+                tree.add(f"[bold]{dir_name}/[/bold] {summary}")
 
     console.print(Panel(tree, expand=False))
 
@@ -145,8 +150,7 @@ def status(
     """Show sync status between files and database."""
     try:
         sync_service = asyncio.run(get_file_change_scanner())
-        asyncio.run(run_status(sync_service, verbose))
+        asyncio.run(run_status(sync_service, verbose))  # pragma: no cover
     except Exception as e:
         logger.exception(f"Error checking status: {e}")
-        typer.echo(f"Error checking status: {e}", err=True)
-        raise typer.Exit(1)
+        raise typer.Exit(code=1)  # pragma: no cover

basic_memory/cli/commands/sync.py

@@ -9,9 +9,6 @@ from typing import List, Dict
 import typer
 from loguru import logger
 from rich.console import Console
-from rich.padding import Padding
-from rich.panel import Panel
-from rich.text import Text
 from rich.tree import Tree
 
 from basic_memory import db
@@ -42,7 +39,7 @@ class ValidationIssue:
     error: str
 
 
-async def get_sync_service(db_type=DatabaseType.FILESYSTEM):
+async def get_sync_service(db_type=DatabaseType.FILESYSTEM):  # pragma: no cover
     """Get sync service instance with all dependencies."""
     async with db.engine_session_factory(db_path=config.database_path, db_type=db_type) as (
         engine,
@@ -97,53 +94,6 @@ def group_issues_by_directory(issues: List[ValidationIssue]) -> Dict[str, List[V
     return dict(grouped)
 
 
-def display_validation_errors(issues: List[ValidationIssue]):
-    """Display validation errors in a rich, organized format."""
-    # Create header
-    console.print()
-    console.print(
-        Panel("[red bold]Error:[/red bold] Invalid frontmatter in knowledge files", expand=False)
-    )
-    console.print()
-
-    # Group issues by directory
-    grouped_issues = group_issues_by_directory(issues)
-
-    # Create tree structure
-    tree = Tree("Knowledge Files")
-    for dir_name, dir_issues in sorted(grouped_issues.items()):
-        # Create branch for directory
-        branch = tree.add(
-            f"[bold blue]{dir_name}/[/bold blue] ([yellow]{len(dir_issues)} files[/yellow])"
-        )
-
-        # Add each file issue
-        for issue in sorted(dir_issues, key=lambda x: x.file_path):
-            file_name = Path(issue.file_path).name
-            branch.add(
-                Text.assemble(("└─ ", "dim"), (file_name, "yellow"), ": ", (issue.error, "red"))
-            )
-
-    # Display tree
-    console.print(Padding(tree, (1, 2)))
-
-    # Add help text
-    console.print()
-    console.print(
-        Panel(
-            Text.assemble(
-                ("To fix:", "bold"),
-                "\n1. Add required frontmatter fields to each file",
-                "\n2. Run ",
-                ("basic-memory sync", "bold cyan"),
-                " again",
-            ),
-            expand=False,
-        )
-    )
-    console.print()
-
-
 def display_sync_summary(knowledge: SyncReport):
     """Display a one-line summary of sync changes."""
     total_changes = knowledge.total_changes
@@ -204,7 +154,6 @@ def display_detailed_sync_results(knowledge: SyncReport):
 
 async def run_sync(verbose: bool = False, watch: bool = False):
     """Run sync operation."""
-
     sync_service = await get_sync_service()
 
     # Start watching if requested
@@ -212,10 +161,10 @@ async def run_sync(verbose: bool = False, watch: bool = False):
         watch_service = WatchService(
             sync_service=sync_service,
             file_service=sync_service.entity_service.file_service,
-            config=config
+            config=config,
         )
         await watch_service.handle_changes(config.home)
-        await watch_service.run()
+        await watch_service.run()  # pragma: no cover
     else:
         # one time sync
         knowledge_changes = await sync_service.sync(config.home)
@@ -223,7 +172,7 @@ async def run_sync(verbose: bool = False, watch: bool = False):
         if verbose:
             display_detailed_sync_results(knowledge_changes)
         else:
-            display_sync_summary(knowledge_changes)
+            display_sync_summary(knowledge_changes)  # pragma: no cover
 
 
 @app.command()
@@ -246,7 +195,7 @@ def sync(
         # Run sync
         asyncio.run(run_sync(verbose=verbose, watch=watch))
 
-    except Exception as e:
+    except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
             logger.exception("Sync failed")
             typer.echo(f"Error during sync: {e}", err=True)

basic_memory/cli/main.py

@@ -1,47 +1,14 @@
-"""Main CLI entry point for basic-memory."""
-import sys
+"""Main CLI entry point for basic-memory."""  # pragma: no cover
 
-import typer
-from loguru import logger
-
-from basic_memory.cli.app import app
+from basic_memory.cli.app import app  # pragma: no cover
+from basic_memory.utils import setup_logging  # pragma: no cover
 
 # Register commands
-from basic_memory.cli.commands import status, sync
-__all__ = ["status", "sync"]
-
-from basic_memory.config import config
-
-
-def setup_logging(home_dir: str = config.home, log_file: str = ".basic-memory/basic-memory-tools.log"):
-    """Configure logging for the application."""
-
-    # Remove default handler and any existing handlers
-    logger.remove()
-
-    # Add file handler for debug level logs
-    log = f"{home_dir}/{log_file}"
-    logger.add(
-        log,
-        level="DEBUG",
-        rotation="100 MB",
-        retention="10 days",
-        backtrace=True,
-        diagnose=True,
-        enqueue=True,
-        colorize=False,
-    )
+from basic_memory.cli.commands import status, sync, db, import_memory_json, mcp  # noqa: F401  # pragma: no cover
 
-    # Add stderr handler for warnings and errors only
-    logger.add(
-        sys.stderr,
-        level="WARNING",
-        backtrace=True,
-        diagnose=True
-    )
 
 # Set up logging when module is imported
-setup_logging()
+setup_logging(log_file=".basic-memory/basic-memory-cli.log")  # pragma: no cover
 
 if __name__ == "__main__":  # pragma: no cover
     app()

basic_memory/config.py

@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-from loguru import logger
 from pydantic import Field, field_validator
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
@@ -27,6 +26,8 @@ class ProjectConfig(BaseSettings):
         default=500, description="Milliseconds to wait after changes before syncing", gt=0
     )
 
+    log_level: str = "INFO"
+
     model_config = SettingsConfigDict(
         env_prefix="BASIC_MEMORY_",
         extra="ignore",
@@ -45,7 +46,7 @@ class ProjectConfig(BaseSettings):
 
     @field_validator("home")
     @classmethod
-    def ensure_path_exists(cls, v: Path) -> Path:
+    def ensure_path_exists(cls, v: Path) -> Path:  # pragma: no cover
         """Ensure project path exists."""
         if not v.exists():
             v.mkdir(parents=True)
@@ -54,4 +55,3 @@ class ProjectConfig(BaseSettings):
 
 # Load project config
 config = ProjectConfig()
-logger.info(f"project config home: {config.home}")

basic_memory/db.py

@@ -14,9 +14,8 @@ from sqlalchemy.ext.asyncio import (
     async_scoped_session,
 )
 
-from basic_memory.models import Base, SCHEMA_VERSION
+from basic_memory.models import Base
 from basic_memory.models.search import CREATE_SEARCH_INDEX
-from basic_memory.repository.search_repository import SearchRepository
 
 # Module level state
 _engine: Optional[AsyncEngine] = None
@@ -72,6 +71,8 @@ async def scoped_session(
 
 async def init_db() -> None:
     """Initialize database with required tables."""
+    if _session_maker is None:  # pragma: no cover
+        raise RuntimeError("Database session maker not initialized")
 
     logger.info("Initializing database...")
 
@@ -85,25 +86,11 @@ async def init_db() -> None:
 
         await session.commit()
 
-async def drop_db():
-    """Drop all database tables."""
-    global _engine, _session_maker
-    
-    logger.info("Dropping tables...")
-    async with scoped_session(_session_maker) as session:
-        conn = await session.connection()
-        await conn.run_sync(Base.metadata.drop_all)
-        await session.commit()
-        
-    # reset global engine and session_maker
-    _engine = None
-    _session_maker = None
-
 
 async def get_or_create_db(
     db_path: Path,
     db_type: DatabaseType = DatabaseType.FILESYSTEM,
-) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
+) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:  # pragma: no cover
     """Get or create database engine and session maker."""
     global _engine, _session_maker
 
@@ -116,10 +103,12 @@ async def get_or_create_db(
         # Initialize database
         await init_db()
 
+    assert _engine is not None  # for type checker
+    assert _session_maker is not None  # for type checker
     return _engine, _session_maker
 
 
-async def shutdown_db():
+async def shutdown_db() -> None:  # pragma: no cover
     """Clean up database connections."""
     global _engine, _session_maker
 
@@ -129,7 +118,6 @@ async def shutdown_db():
         _session_maker = None
 
 
-
 @asynccontextmanager
 async def engine_session_factory(
     db_path: Path,
@@ -143,10 +131,10 @@ async def engine_session_factory(
     """
 
     global _engine, _session_maker
-    
+
     db_url = DatabaseType.get_db_url(db_path, db_type)
     logger.debug(f"Creating engine for db_url: {db_url}")
-    
+
     _engine = create_async_engine(db_url, connect_args={"check_same_thread": False})
     try:
         _session_maker = async_sessionmaker(_engine, expire_on_commit=False)
@@ -154,6 +142,11 @@ async def engine_session_factory(
         if init:
             await init_db()
 
+        assert _engine is not None  # for type checker
+        assert _session_maker is not None  # for type checker
         yield _engine, _session_maker
     finally:
-        await _engine.dispose()
+        if _engine:
+            await _engine.dispose()
+            _engine = None
+            _session_maker = None

basic_memory/deps.py

@@ -29,11 +29,11 @@ from basic_memory.services.search_service import SearchService
 ## project
 
 
-def get_project_config() -> ProjectConfig:
+def get_project_config() -> ProjectConfig:  # pragma: no cover
     return config
 
 
-ProjectConfigDep = Annotated[ProjectConfig, Depends(get_project_config)]
+ProjectConfigDep = Annotated[ProjectConfig, Depends(get_project_config)]  # pragma: no cover
 
 
 ## sqlalchemy
@@ -41,7 +41,7 @@ ProjectConfigDep = Annotated[ProjectConfig, Depends(get_project_config)]
 
 async def get_engine_factory(
     project_config: ProjectConfigDep,
-) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:
+) -> tuple[AsyncEngine, async_sessionmaker[AsyncSession]]:  # pragma: no cover
     """Get engine and session maker."""
     return await db.get_or_create_db(project_config.database_path)
 
@@ -129,7 +129,6 @@ async def get_file_service(
 FileServiceDep = Annotated[FileService, Depends(get_file_service)]
 
 
-
 async def get_entity_service(
     entity_repository: EntityRepositoryDep,
     observation_repository: ObservationRepositoryDep,