basic-memory 0.14.4__py3-none-any.whl → 0.15.1__py3-none-any.whl

basic_memory/cli/commands/sync.py

@@ -1,242 +1,59 @@
 """Command module for basic-memory sync operations."""
 
 import asyncio
-from collections import defaultdict
-from dataclasses import dataclass
-from pathlib import Path
-from typing import List, Dict
+from typing import Annotated, Optional
 
 import typer
-from loguru import logger
-from rich.console import Console
-from rich.tree import Tree
 
-from basic_memory import db
 from basic_memory.cli.app import app
-from basic_memory.config import ConfigManager, get_project_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
-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
-
-console = Console()
-
-
-@dataclass
-class ValidationIssue:
-    file_path: str
-    error: str
-
-
-async def get_sync_service(project: Project) -> SyncService:  # pragma: no cover
-    """Get sync service instance with all dependencies."""
-
-    app_config = ConfigManager().config
-    _, session_maker = await db.get_or_create_db(
-        db_path=app_config.database_path, db_type=db.DatabaseType.FILESYSTEM
-    )
-
-    project_path = Path(project.path)
-    entity_parser = EntityParser(project_path)
-    markdown_processor = MarkdownProcessor(entity_parser)
-    file_service = FileService(project_path, markdown_processor)
-
-    # Initialize repositories
-    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)
-    link_resolver = LinkResolver(entity_repository, search_service)
-
-    # Initialize services
-    entity_service = EntityService(
-        entity_parser,
-        entity_repository,
-        observation_repository,
-        relation_repository,
-        file_service,
-        link_resolver,
-    )
-
-    # Create sync service
-    sync_service = SyncService(
-        app_config=app_config,
-        entity_service=entity_service,
-        entity_parser=entity_parser,
-        entity_repository=entity_repository,
-        relation_repository=relation_repository,
-        search_service=search_service,
-        file_service=file_service,
-    )
-
-    return sync_service
-
-
-def group_issues_by_directory(issues: List[ValidationIssue]) -> Dict[str, List[ValidationIssue]]:
-    """Group validation issues by directory."""
-    grouped = defaultdict(list)
-    for issue in issues:
-        dir_name = Path(issue.file_path).parent.name
-        grouped[dir_name].append(issue)
-    return dict(grouped)
-
-
-def display_sync_summary(knowledge: SyncReport):
-    """Display a one-line summary of sync changes."""
-    config = get_project_config()
-    total_changes = knowledge.total
-    project_name = config.project
-
-    if total_changes == 0:
-        console.print(f"[green]Project '{project_name}': Everything up to date[/green]")
-        return
-
-    # Format as: "Synced X files (A new, B modified, C moved, D deleted)"
-    changes = []
-    new_count = len(knowledge.new)
-    mod_count = len(knowledge.modified)
-    move_count = len(knowledge.moves)
-    del_count = len(knowledge.deleted)
-
-    if new_count:
-        changes.append(f"[green]{new_count} new[/green]")
-    if mod_count:
-        changes.append(f"[yellow]{mod_count} modified[/yellow]")
-    if move_count:
-        changes.append(f"[blue]{move_count} moved[/blue]")
-    if del_count:
-        changes.append(f"[red]{del_count} deleted[/red]")
-
-    console.print(f"Project '{project_name}': Synced {total_changes} files ({', '.join(changes)})")
-
-
-def display_detailed_sync_results(knowledge: SyncReport):
-    """Display detailed sync results with trees."""
-    config = get_project_config()
-    project_name = config.project
-
-    if knowledge.total == 0:
-        console.print(f"\n[green]Project '{project_name}': Everything up to date[/green]")
-        return
-
-    console.print(f"\n[bold]Sync Results for Project '{project_name}'[/bold]")
-
-    if knowledge.total > 0:
-        knowledge_tree = Tree("[bold]Knowledge Files[/bold]")
-        if knowledge.new:
-            created = knowledge_tree.add("[green]Created[/green]")
-            for path in sorted(knowledge.new):
-                checksum = knowledge.checksums.get(path, "")
-                created.add(f"[green]{path}[/green] ({checksum[:8]})")
-        if knowledge.modified:
-            modified = knowledge_tree.add("[yellow]Modified[/yellow]")
-            for path in sorted(knowledge.modified):
-                checksum = knowledge.checksums.get(path, "")
-                modified.add(f"[yellow]{path}[/yellow] ({checksum[:8]})")
-        if knowledge.moves:
-            moved = knowledge_tree.add("[blue]Moved[/blue]")
-            for old_path, new_path in sorted(knowledge.moves.items()):
-                checksum = knowledge.checksums.get(new_path, "")
-                moved.add(f"[blue]{old_path}[/blue] → [blue]{new_path}[/blue] ({checksum[:8]})")
-        if knowledge.deleted:
-            deleted = knowledge_tree.add("[red]Deleted[/red]")
-            for path in sorted(knowledge.deleted):
-                deleted.add(f"[red]{path}[/red]")
-        console.print(knowledge_tree)
-
-
-async def run_sync(verbose: bool = False):
-    """Run sync operation."""
-    app_config = ConfigManager().config
-    config = get_project_config()
-
-    _, 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()
-
-    logger.info(
-        "Sync command started",
-        project=config.project,
-        verbose=verbose,
-        directory=str(config.home),
-    )
-
-    sync_service = await get_sync_service(project)
-
-    logger.info("Running one-time sync")
-    knowledge_changes = await sync_service.sync(config.home, project_name=project.name)
-
-    # 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
+from basic_memory.cli.commands.command_utils import run_sync
+from basic_memory.config import ConfigManager
 
 
 @app.command()
 def sync(
-    verbose: bool = typer.Option(
-        False,
-        "--verbose",
-        "-v",
-        help="Show detailed sync information.",
-    ),
+    project: Annotated[
+        Optional[str],
+        typer.Option(help="The project name."),
+    ] = None,
+    watch: Annotated[
+        bool,
+        typer.Option("--watch", help="Run continuous sync (cloud mode only)"),
+    ] = False,
+    interval: Annotated[
+        int,
+        typer.Option("--interval", help="Sync interval in seconds for watch mode (default: 60)"),
+    ] = 60,
 ) -> None:
-    """Sync knowledge files with the database."""
-    config = get_project_config()
-
-    try:
-        # Show which project we're syncing
-        typer.echo(f"Syncing project: {config.project}")
-        typer.echo(f"Project path: {config.home}")
-
-        # Run sync
-        asyncio.run(run_sync(verbose=verbose))
-
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            logger.exception(
-                "Sync command failed",
-                f"project={config.project},"
-                f"error={str(e)},"
-                f"error_type={type(e).__name__},"
-                f"directory={str(config.home)}",
+    """Sync knowledge files with the database.
+
+    In local mode: Scans filesystem and updates database.
+    In cloud mode: Runs bidirectional file sync (bisync) then updates database.
+
+    Examples:
+      bm sync                    # One-time sync
+      bm sync --watch            # Continuous sync every 60s
+      bm sync --watch --interval 30  # Continuous sync every 30s
+    """
+    config = ConfigManager().config
+
+    if config.cloud_mode_enabled:
+        # Cloud mode: run bisync which includes database sync
+        from basic_memory.cli.commands.cloud.bisync_commands import run_bisync, run_bisync_watch
+
+        try:
+            if watch:
+                run_bisync_watch(interval_seconds=interval)
+            else:
+                run_bisync()
+        except Exception:
+            raise typer.Exit(1)
+    else:
+        # Local mode: just database sync
+        if watch:
+            typer.echo(
+                "Error: --watch is only available in cloud mode. Run 'bm cloud login' first."
             )
-            typer.echo(f"Error during sync: {e}", err=True)
             raise typer.Exit(1)
-        raise
+
+        asyncio.run(run_sync(project))

basic_memory/cli/commands/tool.py

@@ -9,6 +9,7 @@ from loguru import logger
 from rich import print as rprint
 
 from basic_memory.cli.app import app
+from basic_memory.config import ConfigManager
 
 # Import prompts
 from basic_memory.mcp.prompts.continue_conversation import (
@@ -34,6 +35,12 @@ app.add_typer(tool_app, name="tool", help="Access to MCP tools via CLI")
 def write_note(
     title: Annotated[str, typer.Option(help="The title of the note")],
     folder: Annotated[str, typer.Option(help="The folder to create the note in")],
+    project: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The project to write to. If not provided, the default project will be used."
+        ),
+    ] = None,
     content: Annotated[
         Optional[str],
         typer.Option(
@@ -90,7 +97,19 @@ def write_note(
             typer.echo("Empty content provided. Please provide non-empty content.", err=True)
             raise typer.Exit(1)
 
-        note = asyncio.run(mcp_write_note.fn(title, content, folder, tags))
+        # look for the project in the config
+        config_manager = ConfigManager()
+        project_name = None
+        if project is not None:
+            project_name, _ = config_manager.get_project(project)
+            if not project_name:
+                typer.echo(f"No project found named: {project}", err=True)
+                raise typer.Exit(1)
+
+        # use the project name, or the default from the config
+        project_name = project_name or config_manager.default_project
+
+        note = asyncio.run(mcp_write_note.fn(title, content, folder, project_name, tags))
         rprint(note)
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
@@ -100,10 +119,33 @@ def write_note(
 
 
 @tool_app.command()
-def read_note(identifier: str, page: int = 1, page_size: int = 10):
+def read_note(
+    identifier: str,
+    project: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The project to use for the note. If not provided, the default project will be used."
+        ),
+    ] = None,
+    page: int = 1,
+    page_size: int = 10,
+):
     """Read a markdown note from the knowledge base."""
+
+    # look for the project in the config
+    config_manager = ConfigManager()
+    project_name = None
+    if project is not None:
+        project_name, _ = config_manager.get_project(project)
+        if not project_name:
+            typer.echo(f"No project found named: {project}", err=True)
+            raise typer.Exit(1)
+
+    # use the project name, or the default from the config
+    project_name = project_name or config_manager.default_project
+
     try:
-        note = asyncio.run(mcp_read_note.fn(identifier, page, page_size))
+        note = asyncio.run(mcp_read_note.fn(identifier, project_name, page, page_size))
         rprint(note)
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
@@ -115,6 +157,10 @@ def read_note(identifier: str, page: int = 1, page_size: int = 10):
 @tool_app.command()
 def build_context(
     url: MemoryUrl,
+    project: Annotated[
+        Optional[str],
+        typer.Option(help="The project to use. If not provided, the default project will be used."),
+    ] = None,
     depth: Optional[int] = 1,
     timeframe: Optional[TimeFrame] = "7d",
     page: int = 1,
@@ -122,9 +168,23 @@ def build_context(
     max_related: int = 10,
 ):
     """Get context needed to continue a discussion."""
+
+    # look for the project in the config
+    config_manager = ConfigManager()
+    project_name = None
+    if project is not None:
+        project_name, _ = config_manager.get_project(project)
+        if not project_name:
+            typer.echo(f"No project found named: {project}", err=True)
+            raise typer.Exit(1)
+
+    # use the project name, or the default from the config
+    project_name = project_name or config_manager.default_project
+
     try:
         context = asyncio.run(
             mcp_build_context.fn(
+                project=project_name,
                 url=url,
                 depth=depth,
                 timeframe=timeframe,
@@ -150,30 +210,21 @@ def recent_activity(
     type: Annotated[Optional[List[SearchItemType]], typer.Option()] = None,
     depth: Optional[int] = 1,
     timeframe: Optional[TimeFrame] = "7d",
-    page: int = 1,
-    page_size: int = 10,
-    max_related: int = 10,
 ):
     """Get recent activity across the knowledge base."""
     try:
-        context = asyncio.run(
+        result = asyncio.run(
             mcp_recent_activity.fn(
                 type=type,  # pyright: ignore [reportArgumentType]
                 depth=depth,
                 timeframe=timeframe,
-                page=page,
-                page_size=page_size,
-                max_related=max_related,
             )
         )
-        # Use json module for more controlled serialization
-        import json
-
-        context_dict = context.model_dump(exclude_none=True)
-        print(json.dumps(context_dict, indent=2, ensure_ascii=True, default=str))
+        # The tool now returns a formatted string directly
+        print(result)
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during build_context: {e}", err=True)
+            typer.echo(f"Error during recent_activity: {e}", err=True)
             raise typer.Exit(1)
         raise
 
@@ -183,6 +234,12 @@ def search_notes(
     query: str,
     permalink: Annotated[bool, typer.Option("--permalink", help="Search permalink values")] = False,
     title: Annotated[bool, typer.Option("--title", help="Search title values")] = False,
+    project: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The project to use for the note. If not provided, the default project will be used."
+        ),
+    ] = None,
     after_date: Annotated[
         Optional[str],
         typer.Option("--after_date", help="Search results after date, eg. '2d', '1 week'"),
@@ -191,6 +248,19 @@ def search_notes(
     page_size: int = 10,
 ):
     """Search across all content in the knowledge base."""
+
+    # look for the project in the config
+    config_manager = ConfigManager()
+    project_name = None
+    if project is not None:
+        project_name, _ = config_manager.get_project(project)
+        if not project_name:
+            typer.echo(f"No project found named: {project}", err=True)
+            raise typer.Exit(1)
+
+    # use the project name, or the default from the config
+    project_name = project_name or config_manager.default_project
+
     if permalink and title:  # pragma: no cover
         print("Cannot search both permalink and title")
         raise typer.Abort()
@@ -212,6 +282,7 @@ def search_notes(
         results = asyncio.run(
             mcp_search.fn(
                 query,
+                project_name,
                 search_type=search_type,
                 page=page,
                 after_date=after_date,

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
+    cloud,
     db,
     import_chatgpt,
     import_claude_conversations,