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

basic_memory/cli/commands/import_memory_json.py

@@ -3,94 +3,20 @@
 import asyncio
 import json
 from pathlib import Path
-from typing import Dict, Any, List, Annotated
+from typing import Annotated
 
 import typer
-from loguru import logger
-from rich.console import Console
-from rich.panel import Panel
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
-
 from basic_memory.cli.app import import_app
 from basic_memory.config import config
+from basic_memory.importers.memory_json_importer import MemoryJsonImporter
 from basic_memory.markdown import EntityParser, MarkdownProcessor
-from basic_memory.markdown.schemas import EntityMarkdown, EntityFrontmatter, Observation, Relation
+from loguru import logger
+from rich.console import Console
+from rich.panel import Panel
 
 console = Console()
 
 
-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}"),
-        BarColumn(),
-        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
-        console=console,
-    ) as progress:
-        read_task = progress.add_task("Reading memory.json...", total=None)
-
-        # First pass - collect entities and relations
-        with open(json_path, encoding="utf-8") as f:
-            lines = f.readlines()
-            progress.update(read_task, total=len(lines))
-
-            for line in lines:
-                data = json.loads(line)
-                if data["type"] == "entity":
-                    entities[data["name"]] = data
-                elif data["type"] == "relation":
-                    # Store relation with its source entity
-                    source = data.get("from") or data.get("from_id")
-                    if source not in entity_relations:
-                        entity_relations[source] = []
-                    entity_relations[source].append(
-                        Relation(
-                            type=data.get("relationType") or data.get("relation_type"),
-                            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(
-                frontmatter=EntityFrontmatter(
-                    metadata={
-                        "type": entity_data["entityType"],
-                        "title": 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
-            )
-
-            # 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()),
-    }
-
-
 async def get_markdown_processor() -> MarkdownProcessor:
     """Get MarkdownProcessor instance."""
     entity_parser = EntityParser(config.home)
@@ -102,6 +28,9 @@ def memory_json(
     json_path: Annotated[Path, typer.Argument(..., help="Path to memory.json file")] = Path(
         "memory.json"
     ),
+    destination_folder: Annotated[
+        str, typer.Option(help="Optional destination folder within the project")
+    ] = "",
 ):
     """Import entities and relations from a memory.json file.
 
@@ -121,17 +50,31 @@ def memory_json(
         # Get markdown processor
         markdown_processor = asyncio.run(get_markdown_processor())
 
+        # Create the importer
+        importer = MemoryJsonImporter(config.home, markdown_processor)
+
         # Process the file
-        base_path = config.home
+        base_path = config.home if not destination_folder else config.home / destination_folder
         console.print(f"\nImporting from {json_path}...writing to {base_path}")
-        results = asyncio.run(process_memory_json(json_path, base_path, markdown_processor))
+
+        # Run the import for json log format
+        file_data = []
+        with json_path.open("r", encoding="utf-8") as file:
+            for line in file:
+                json_data = json.loads(line)
+                file_data.append(json_data)
+        result = asyncio.run(importer.import_data(file_data, destination_folder))
+
+        if not result.success:  # pragma: no cover
+            typer.echo(f"Error during import: {result.error_message}", err=True)
+            raise typer.Exit(1)
 
         # Show results
         console.print(
             Panel(
                 f"[green]Import complete![/green]\n\n"
-                f"Created {results['entities']} entities\n"
-                f"Added {results['relations']} relations",
+                f"Created {result.entities} entities\n"
+                f"Added {result.relations} relations",
                 expand=False,
             )
         )

basic_memory/cli/commands/mcp.py

@@ -1,6 +1,8 @@
-"""MCP server command."""
+"""MCP server command with streamable HTTP transport."""
+
+import asyncio
+import typer
 
-import basic_memory
 from basic_memory.cli.app import app
 
 # Import mcp instance
@@ -9,27 +11,78 @@ 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
 
+# Import prompts to register them
+import basic_memory.mcp.prompts  # noqa: F401  # pragma: no cover
+from loguru import logger
+
 
 @app.command()
-def mcp():  # pragma: no cover
-    """Run the MCP server"""
-    from basic_memory.config import config
-    import asyncio
-    from basic_memory.services.initialization import initialize_database
+def mcp(
+    transport: str = typer.Option("stdio", help="Transport type: stdio, streamable-http, or sse"),
+    host: str = typer.Option(
+        "0.0.0.0", help="Host for HTTP transports (use 0.0.0.0 to allow external connections)"
+    ),
+    port: int = typer.Option(8000, help="Port for HTTP transports"),
+    path: str = typer.Option("/mcp", help="Path prefix for streamable-http transport"),
+):  # pragma: no cover
+    """Run the MCP server with configurable transport options.
+
+    This command starts an MCP server using one of three transport options:
+
+    - stdio: Standard I/O (good for local usage)
+    - streamable-http: Recommended for web deployments (default)
+    - sse: Server-Sent Events (for compatibility with existing clients)
+    """
+
+    # Check if OAuth is enabled
+    import os
+
+    auth_enabled = os.getenv("FASTMCP_AUTH_ENABLED", "false").lower() == "true"
+    if auth_enabled:
+        logger.info("OAuth authentication is ENABLED")
+        logger.info(f"Issuer URL: {os.getenv('FASTMCP_AUTH_ISSUER_URL', 'http://localhost:8000')}")
+        if os.getenv("FASTMCP_AUTH_REQUIRED_SCOPES"):
+            logger.info(f"Required scopes: {os.getenv('FASTMCP_AUTH_REQUIRED_SCOPES')}")
+    else:
+        logger.info("OAuth authentication is DISABLED")
+
+    from basic_memory.config import app_config
+    from basic_memory.services.initialization import initialize_file_sync
 
-    # First, run just the database migrations synchronously
-    asyncio.run(initialize_database(config))
+    # Start the MCP server with the specified transport
 
-    # Load config to check if sync is enabled
-    from basic_memory.config import config_manager
+    # Use unified thread-based sync approach for both transports
+    import threading
 
-    basic_memory_config = config_manager.load_config()
+    def run_file_sync():
+        """Run file sync in a separate thread with its own event loop."""
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            loop.run_until_complete(initialize_file_sync(app_config))
+        except Exception as e:
+            logger.error(f"File sync error: {e}", err=True)
+        finally:
+            loop.close()
 
-    if basic_memory_config.sync_changes:
-        # For now, we'll just log that sync will be handled by the MCP server
-        from loguru import logger
+    logger.info(f"Sync changes enabled: {app_config.sync_changes}")
+    if app_config.sync_changes:
+        # Start the sync thread
+        sync_thread = threading.Thread(target=run_file_sync, daemon=True)
+        sync_thread.start()
+        logger.info("Started file sync in background")
 
-        logger.info("File sync will be handled by the MCP server")
+    # Now run the MCP server (blocks)
+    logger.info(f"Starting MCP server with {transport.upper()} transport")
 
-    # Start the MCP server
-    mcp_server.run()
+    if transport == "stdio":
+        mcp_server.run(
+            transport=transport,
+        )
+    elif transport == "streamable-http" or transport == "sse":
+        mcp_server.run(
+            transport=transport,
+            host=host,
+            port=port,
+            path=path,
+        )

basic_memory/cli/commands/project.py

@@ -9,13 +9,21 @@ from rich.console import Console
 from rich.table import Table
 
 from basic_memory.cli.app import app
-from basic_memory.config import ConfigManager, config
-from basic_memory.mcp.tools.project_info import project_info
+from basic_memory.config import config
+from basic_memory.mcp.project_session import session
+from basic_memory.mcp.resources.project_info import project_info
 import json
 from datetime import datetime
 
 from rich.panel import Panel
 from rich.tree import Tree
+from basic_memory.mcp.async_client import client
+from basic_memory.mcp.tools.utils import call_get
+from basic_memory.schemas.project_info import ProjectList
+from basic_memory.mcp.tools.utils import call_post
+from basic_memory.schemas.project_info import ProjectStatusResponse
+from basic_memory.mcp.tools.utils import call_delete
+from basic_memory.mcp.tools.utils import call_put
 
 console = Console()
 
@@ -28,112 +36,135 @@ def format_path(path: str) -> str:
     """Format a path for display, using ~ for home directory."""
     home = str(Path.home())
     if path.startswith(home):
-        return path.replace(home, "~", 1)
+        return path.replace(home, "~", 1)  # pragma: no cover
     return path
 
 
 @project_app.command("list")
 def list_projects() -> None:
     """List all configured projects."""
-    config_manager = ConfigManager()
-    projects = config_manager.projects
+    # Use API to list projects
 
-    table = Table(title="Basic Memory Projects")
-    table.add_column("Name", style="cyan")
-    table.add_column("Path", style="green")
-    table.add_column("Default", style="yellow")
-    table.add_column("Active", style="magenta")
+    project_url = config.project_url
 
-    default_project = config_manager.default_project
-    active_project = config.project
-
-    for name, path in projects.items():
-        is_default = "✓" if name == default_project else ""
-        is_active = "✓" if name == active_project else ""
-        table.add_row(name, format_path(path), is_default, is_active)
-
-    console.print(table)
+    try:
+        response = asyncio.run(call_get(client, f"{project_url}/project/projects"))
+        result = ProjectList.model_validate(response.json())
+
+        table = Table(title="Basic Memory Projects")
+        table.add_column("Name", style="cyan")
+        table.add_column("Path", style="green")
+        table.add_column("Default", style="yellow")
+        table.add_column("Active", style="magenta")
+
+        for project in result.projects:
+            is_default = "✓" if project.is_default else ""
+            is_active = "✓" if session.get_current_project() == project.name else ""
+            table.add_row(project.name, format_path(project.path), is_default, is_active)
+
+        console.print(table)
+    except Exception as e:
+        console.print(f"[red]Error listing projects: {str(e)}[/red]")
+        console.print("[yellow]Note: Make sure the Basic Memory server is running.[/yellow]")
+        raise typer.Exit(1)
 
 
 @project_app.command("add")
 def add_project(
     name: str = typer.Argument(..., help="Name of the project"),
     path: str = typer.Argument(..., help="Path to the project directory"),
+    set_default: bool = typer.Option(False, "--default", help="Set as default project"),
 ) -> None:
     """Add a new project."""
-    config_manager = ConfigManager()
+    # Resolve to absolute path
+    resolved_path = os.path.abspath(os.path.expanduser(path))
 
     try:
-        # Resolve to absolute path
-        resolved_path = os.path.abspath(os.path.expanduser(path))
-        config_manager.add_project(name, resolved_path)
-        console.print(f"[green]Project '{name}' added at {format_path(resolved_path)}[/green]")
-
-        # Display usage hint
-        console.print("\nTo use this project:")
-        console.print(f"  basic-memory --project={name} <command>")
-        console.print("  # or")
-        console.print(f"  basic-memory project default {name}")
-    except ValueError as e:
-        console.print(f"[red]Error: {e}[/red]")
+        project_url = config.project_url
+        data = {"name": name, "path": resolved_path, "set_default": set_default}
+
+        response = asyncio.run(call_post(client, f"{project_url}/project/projects", json=data))
+        result = ProjectStatusResponse.model_validate(response.json())
+
+        console.print(f"[green]{result.message}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error adding project: {str(e)}[/red]")
+        console.print("[yellow]Note: Make sure the Basic Memory server is running.[/yellow]")
         raise typer.Exit(1)
 
+    # Display usage hint
+    console.print("\nTo use this project:")
+    console.print(f"  basic-memory --project={name} <command>")
+    console.print("  # or")
+    console.print(f"  basic-memory project default {name}")
+
 
 @project_app.command("remove")
 def remove_project(
     name: str = typer.Argument(..., help="Name of the project to remove"),
 ) -> None:
     """Remove a project from configuration."""
-    config_manager = ConfigManager()
-
     try:
-        config_manager.remove_project(name)
-        console.print(f"[green]Project '{name}' removed from configuration[/green]")
-        console.print("[yellow]Note: The project files have not been deleted from disk.[/yellow]")
-    except ValueError as e:  # pragma: no cover
-        console.print(f"[red]Error: {e}[/red]")
+        project_url = config.project_url
+
+        response = asyncio.run(call_delete(client, f"{project_url}/project/projects/{name}"))
+        result = ProjectStatusResponse.model_validate(response.json())
+
+        console.print(f"[green]{result.message}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error removing project: {str(e)}[/red]")
+        console.print("[yellow]Note: Make sure the Basic Memory server is running.[/yellow]")
         raise typer.Exit(1)
 
+    # Show this message regardless of method used
+    console.print("[yellow]Note: The project files have not been deleted from disk.[/yellow]")
+
 
 @project_app.command("default")
 def set_default_project(
     name: str = typer.Argument(..., help="Name of the project to set as default"),
 ) -> None:
     """Set the default project and activate it for the current session."""
-    config_manager = ConfigManager()
-
     try:
-        # Set the default project
-        config_manager.set_default_project(name)
-
-        # Also activate it for the current session by setting the environment variable
-        os.environ["BASIC_MEMORY_PROJECT"] = name
+        project_url = config.project_url
 
-        # Reload configuration to apply the change
-        from importlib import reload
-        from basic_memory import config as config_module
+        response = asyncio.run(call_put(client, f"{project_url}/project/projects/{name}/default"))
+        result = ProjectStatusResponse.model_validate(response.json())
 
-        reload(config_module)
-        console.print(f"[green]Project '{name}' set as default and activated[/green]")
-    except ValueError as e:  # pragma: no cover
-        console.print(f"[red]Error: {e}[/red]")
+        console.print(f"[green]{result.message}[/green]")
+    except Exception as e:
+        console.print(f"[red]Error setting default project: {str(e)}[/red]")
+        console.print("[yellow]Note: Make sure the Basic Memory server is running.[/yellow]")
         raise typer.Exit(1)
 
+    # Always activate it for the current session
+    os.environ["BASIC_MEMORY_PROJECT"] = name
+
+    # Reload configuration to apply the change
+    from importlib import reload
+    from basic_memory import config as config_module
+
+    reload(config_module)
+
+    console.print("[green]Project activated for current session[/green]")
 
-@project_app.command("current")
-def show_current_project() -> None:
-    """Show the current project."""
-    config_manager = ConfigManager()
-    current = os.environ.get("BASIC_MEMORY_PROJECT", config_manager.default_project)
+
+@project_app.command("sync")
+def synchronize_projects() -> None:
+    """Synchronize projects between configuration file and database."""
+    # Call the API to synchronize projects
+
+    project_url = config.project_url
 
     try:
-        path = config_manager.get_project_path(current)
-        console.print(f"Current project: [cyan]{current}[/cyan]")
-        console.print(f"Path: [green]{format_path(str(path))}[/green]")
-        console.print(f"Database: [blue]{format_path(str(config.database_path))}[/blue]")
-    except ValueError:  # pragma: no cover
-        console.print(f"[yellow]Warning: Project '{current}' not found in configuration[/yellow]")
-        console.print(f"Using default project: [cyan]{config_manager.default_project}[/cyan]")
+        response = asyncio.run(call_post(client, f"{project_url}/project/sync"))
+        result = ProjectStatusResponse.model_validate(response.json())
+
+        console.print(f"[green]{result.message}[/green]")
+    except Exception as e:  # pragma: no cover
+        console.print(f"[red]Error synchronizing projects: {str(e)}[/red]")
+        console.print("[yellow]Note: Make sure the Basic Memory server is running.[/yellow]")
+        raise typer.Exit(1)
 
 
 @project_app.command("info")
@@ -266,9 +297,10 @@ def display_project_info(
             projects_table.add_column("Path", style="cyan")
             projects_table.add_column("Default", style="green")
 
-            for name, path in info.available_projects.items():
+            for name, proj_info in info.available_projects.items():
                 is_default = name == info.default_project
-                projects_table.add_row(name, path, "✓" if is_default else "")
+                project_path = proj_info["path"]
+                projects_table.add_row(name, project_path, "✓" if is_default else "")
 
             console.print(projects_table)
 

basic_memory/cli/commands/status.py

@@ -9,10 +9,11 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.tree import Tree
 
+from basic_memory import db
 from basic_memory.cli.app import app
 from basic_memory.cli.commands.sync import get_sync_service
-from basic_memory.config import config
-from basic_memory.sync import SyncService
+from basic_memory.config import config, app_config
+from basic_memory.repository import ProjectRepository
 from basic_memory.sync.sync_service import SyncReport
 
 # Create rich console
@@ -86,9 +87,9 @@ def build_directory_summary(counts: Dict[str, int]) -> str:
     return " ".join(parts)
 
 
-def display_changes(title: str, changes: SyncReport, verbose: bool = False):
+def display_changes(project_name: str, title: str, changes: SyncReport, verbose: bool = False):
     """Display changes using Rich for better visualization."""
-    tree = Tree(title)
+    tree = Tree(f"{project_name}: {title}")
 
     if changes.total == 0:
         tree.add("No changes")
@@ -121,11 +122,21 @@ def display_changes(title: str, changes: SyncReport, verbose: bool = False):
     console.print(Panel(tree, expand=False))
 
 
-async def run_status(sync_service: SyncService, verbose: bool = False):
+async def run_status(verbose: bool = False):
     """Check sync status of files vs database."""
     # Check knowledge/ directory
+
+    _, 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")
+
+    sync_service = await get_sync_service(project)
     knowledge_changes = await sync_service.scan(config.home)
-    display_changes("Status", knowledge_changes, verbose)
+    display_changes(project.name, "Status", knowledge_changes, verbose)
 
 
 @app.command()
@@ -134,9 +145,8 @@ def status(
 ):
     """Show sync status between files and database."""
     try:
-        sync_service = asyncio.run(get_sync_service())
-        asyncio.run(run_status(sync_service, verbose))  # pragma: no cover
+        asyncio.run(run_status(verbose))  # pragma: no cover
     except Exception as e:
-        logger.exception(f"Error checking status: {e}")
+        logger.error(f"Error checking status: {e}")
         typer.echo(f"Error checking status: {e}", err=True)
         raise typer.Exit(code=1)  # pragma: no cover