basic-memory 0.7.0__py3-none-any.whl → 0.16.1__py3-none-any.whl

basic_memory/cli/commands/import_claude_projects.py

@@ -3,142 +3,23 @@
 import asyncio
 import json
 from pathlib import Path
-from typing import Dict, Any, Annotated, Optional
+from typing import Annotated
 
-import logfire
 import typer
+from basic_memory.cli.app import claude_app
+from basic_memory.config import get_project_config
+from basic_memory.importers.claude_projects_importer import ClaudeProjectsImporter
+from basic_memory.markdown import EntityParser, MarkdownProcessor
 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 claude_app
-from basic_memory.config import config
-from basic_memory.markdown import EntityParser, MarkdownProcessor
-from basic_memory.markdown.schemas import EntityMarkdown, EntityFrontmatter
 
 console = Console()
 
 
-def clean_filename(text: str) -> str:
-    """Convert text to safe filename."""
-    clean = "".join(c if c.isalnum() else "-" for c in text.lower()).strip("-")
-    return clean
-
-
-def format_project_markdown(project: Dict[str, Any], doc: Dict[str, Any]) -> EntityMarkdown:
-    """Format a project document as a Basic Memory entity."""
-
-    # Extract timestamps
-    created_at = doc.get("created_at") or project["created_at"]
-    modified_at = project["updated_at"]
-
-    # Generate clean names for organization
-    project_dir = clean_filename(project["name"])
-    doc_file = clean_filename(doc["filename"])
-
-    # Create entity
-    entity = EntityMarkdown(
-        frontmatter=EntityFrontmatter(
-            metadata={
-                "type": "project_doc",
-                "title": doc["filename"],
-                "created": created_at,
-                "modified": modified_at,
-                "permalink": f"{project_dir}/docs/{doc_file}",
-                "project_name": project["name"],
-                "project_uuid": project["uuid"],
-                "doc_uuid": doc["uuid"],
-            }
-        ),
-        content=doc["content"],
-    )
-
-    return entity
-
-
-def format_prompt_markdown(project: Dict[str, Any]) -> Optional[EntityMarkdown]:
-    """Format project prompt template as a Basic Memory entity."""
-
-    if not project.get("prompt_template"):
-        return None
-
-    # Extract timestamps
-    created_at = project["created_at"]
-    modified_at = project["updated_at"]
-
-    # Generate clean project directory name
-    project_dir = clean_filename(project["name"])
-
-    # Create entity
-    entity = EntityMarkdown(
-        frontmatter=EntityFrontmatter(
-            metadata={
-                "type": "prompt_template",
-                "title": f"Prompt Template: {project['name']}",
-                "created": created_at,
-                "modified": modified_at,
-                "permalink": f"{project_dir}/prompt-template",
-                "project_name": project["name"],
-                "project_uuid": project["uuid"],
-            }
-        ),
-        content=f"# Prompt Template: {project['name']}\n\n{project['prompt_template']}",
-    )
-
-    return entity
-
-
-async def process_projects_json(
-    json_path: Path, base_path: Path, markdown_processor: MarkdownProcessor
-) -> Dict[str, int]:
-    """Import project data from Claude.ai projects.json format."""
-
-    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 project data...", total=None)
-
-        # Read project data
-        data = json.loads(json_path.read_text())
-        progress.update(read_task, total=len(data))
-
-        # Track import counts
-        docs_imported = 0
-        prompts_imported = 0
-
-        # Process each project
-        for project in data:
-            project_dir = clean_filename(project["name"])
-
-            # Create project directories
-            docs_dir = base_path / project_dir / "docs"
-            docs_dir.mkdir(parents=True, exist_ok=True)
-
-            # Import prompt template if it exists
-            if prompt_entity := format_prompt_markdown(project):
-                file_path = base_path / f"{prompt_entity.frontmatter.metadata['permalink']}.md"
-                await markdown_processor.write_file(file_path, prompt_entity)
-                prompts_imported += 1
-
-            # Import project documents
-            for doc in project.get("docs", []):
-                entity = format_project_markdown(project, doc)
-                file_path = base_path / f"{entity.frontmatter.metadata['permalink']}.md"
-                await markdown_processor.write_file(file_path, entity)
-                docs_imported += 1
-
-            progress.update(read_task, advance=1)
-
-    return {"documents": docs_imported, "prompts": prompts_imported}
-
-
 async def get_markdown_processor() -> MarkdownProcessor:
     """Get MarkdownProcessor instance."""
+    config = get_project_config()
     entity_parser = EntityParser(config.home)
     return MarkdownProcessor(entity_parser)
 
@@ -161,36 +42,44 @@ def import_projects(
 
     After importing, run 'basic-memory sync' to index the new files.
     """
-    with logfire.span("import claude projects"):  # pyright: ignore [reportGeneralTypeIssues]
-        try:
-            if projects_json:
-                if not projects_json.exists():
-                    typer.echo(f"Error: File not found: {projects_json}", err=True)
-                    raise typer.Exit(1)
-
-                # Get markdown processor
-                markdown_processor = asyncio.run(get_markdown_processor())
-
-                # Process the file
-                base_path = config.home / base_folder if base_folder else config.home
-                console.print(f"\nImporting projects from {projects_json}...writing to {base_path}")
-                results = asyncio.run(
-                    process_projects_json(projects_json, base_path, markdown_processor)
-                )
-
-                # Show results
-                console.print(
-                    Panel(
-                        f"[green]Import complete![/green]\n\n"
-                        f"Imported {results['documents']} project documents\n"
-                        f"Imported {results['prompts']} prompt templates",
-                        expand=False,
-                    )
-                )
-
-            console.print("\nRun 'basic-memory sync' to index the new files.")
-
-        except Exception as e:
-            logger.error("Import failed")
-            typer.echo(f"Error during import: {e}", err=True)
+    config = get_project_config()
+    try:
+        if not projects_json.exists():
+            typer.echo(f"Error: File not found: {projects_json}", err=True)
             raise typer.Exit(1)
+
+        # Get markdown processor
+        markdown_processor = asyncio.run(get_markdown_processor())
+
+        # Create the importer
+        importer = ClaudeProjectsImporter(config.home, markdown_processor)
+
+        # Process the file
+        base_path = config.home / base_folder if base_folder else config.home
+        console.print(f"\nImporting projects from {projects_json}...writing to {base_path}")
+
+        # Run the import
+        with projects_json.open("r", encoding="utf-8") as file:
+            json_data = json.load(file)
+            result = asyncio.run(importer.import_data(json_data, base_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"Imported {result.documents} project documents\n"
+                f"Imported {result.prompts} prompt templates",
+                expand=False,
+            )
+        )
+
+        console.print("\nRun 'basic-memory sync' to index the new files.")
+
+    except Exception as e:
+        logger.error("Import failed")
+        typer.echo(f"Error during import: {e}", err=True)
+        raise typer.Exit(1)

basic_memory/cli/commands/import_memory_json.py

@@ -3,97 +3,23 @@
 import asyncio
 import json
 from pathlib import Path
-from typing import Dict, Any, List, Annotated
+from typing import Annotated
 
-import logfire
 import typer
+from basic_memory.cli.app import import_app
+from basic_memory.config import get_project_config
+from basic_memory.importers.memory_json_importer import MemoryJsonImporter
+from basic_memory.markdown import EntityParser, MarkdownProcessor
 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.markdown import EntityParser, MarkdownProcessor
-from basic_memory.markdown.schemas import EntityMarkdown, EntityFrontmatter, Observation, Relation
 
 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) 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."""
+    config = get_project_config()
     entity_parser = EntityParser(config.home)
     return MarkdownProcessor(entity_parser)
 
@@ -103,6 +29,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.
 
@@ -110,37 +39,48 @@ def memory_json(
     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.
     """
 
-    with logfire.span("import memory_json"):  # pyright: ignore [reportGeneralTypeIssues]
-        if not json_path.exists():
-            typer.echo(f"Error: File not found: {json_path}", err=True)
-            raise typer.Exit(1)
+    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,
-                )
-            )
+    config = get_project_config()
+    try:
+        # Get markdown processor
+        markdown_processor = asyncio.run(get_markdown_processor())
+
+        # Create the importer
+        importer = MemoryJsonImporter(config.home, markdown_processor)
 
-            console.print("\nRun 'basic-memory sync' to index the new files.")
+        # Process the file
+        base_path = config.home if not destination_folder else config.home / destination_folder
+        console.print(f"\nImporting from {json_path}...writing to {base_path}")
 
-        except Exception as e:
-            logger.error("Import failed")
-            typer.echo(f"Error during import: {e}", err=True)
+        # 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 {result.entities} entities\n"
+                f"Added {result.relations} relations\n"
+                f"Skipped {result.skipped_entities} entities\n",
+                expand=False,
+            )
+        )
+
+    except Exception as e:
+        logger.error("Import failed")
+        typer.echo(f"Error during import: {e}", err=True)
+        raise typer.Exit(1)

basic_memory/cli/commands/mcp.py

@@ -1,8 +1,12 @@
-"""MCP server command."""
+"""MCP server command with streamable HTTP transport."""
+
+import asyncio
+import os
+import typer
+from typing import Optional
 
-from loguru import logger
 from basic_memory.cli.app import app
-from basic_memory.config import config
+from basic_memory.config import ConfigManager
 
 # Import mcp instance
 from basic_memory.mcp.server import mcp as mcp_server  # pragma: no cover
@@ -10,11 +14,81 @@ 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
+import threading
+from basic_memory.services.initialization import initialize_file_sync
+
+config = ConfigManager().config
+
+if not config.cloud_mode_enabled:
+
+    @app.command()
+    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"),
+        project: Optional[str] = typer.Option(None, help="Restrict MCP server to single project"),
+    ):  # 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)
+        """
+
+        # Validate and set project constraint if specified
+        if project:
+            config_manager = ConfigManager()
+            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)
+
+            # Set env var with validated project name
+            os.environ["BASIC_MEMORY_MCP_PROJECT"] = project_name
+            logger.info(f"MCP server constrained to project: {project_name}")
+
+        app_config = ConfigManager().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()
+
+        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")
+
+        # Now run the MCP server (blocks)
+        logger.info(f"Starting MCP server with {transport.upper()} transport")
 
-@app.command()
-def mcp():  # pragma: no cover
-    """Run the MCP server for Claude Desktop integration."""
-    home_dir = config.home
-    logger.info(f"Starting Basic Memory MCP server {basic_memory.__version__}")
-    logger.info(f"Home directory: {home_dir}")
-    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,
+                log_level="INFO",
+            )