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

basic_memory/cli/commands/project_info.py

@@ -0,0 +1,167 @@
+"""CLI command for project info status."""
+
+import asyncio
+import json
+from datetime import datetime
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.tree import Tree
+
+from basic_memory.cli.app import app
+from basic_memory.mcp.tools.project_info import project_info
+
+
+info_app = typer.Typer()
+app.add_typer(info_app, name="info", help="Get information about your Basic Memory project")
+
+
+@info_app.command("stats")
+def display_project_info(
+    json_output: bool = typer.Option(False, "--json", help="Output in JSON format"),
+):
+    """Display detailed information and statistics about the current project."""
+    try:
+        # Get project info
+        info = asyncio.run(project_info())
+
+        if json_output:
+            # Convert to JSON and print
+            print(json.dumps(info.model_dump(), indent=2, default=str))
+        else:
+            # Create rich display
+            console = Console()
+
+            # Project configuration section
+            console.print(
+                Panel(
+                    f"[bold]Project:[/bold] {info.project_name}\n"
+                    f"[bold]Path:[/bold] {info.project_path}\n"
+                    f"[bold]Default Project:[/bold] {info.default_project}\n",
+                    title="📊 Basic Memory Project Info",
+                    expand=False,
+                )
+            )
+
+            # Statistics section
+            stats_table = Table(title="📈 Statistics")
+            stats_table.add_column("Metric", style="cyan")
+            stats_table.add_column("Count", style="green")
+
+            stats_table.add_row("Entities", str(info.statistics.total_entities))
+            stats_table.add_row("Observations", str(info.statistics.total_observations))
+            stats_table.add_row("Relations", str(info.statistics.total_relations))
+            stats_table.add_row(
+                "Unresolved Relations", str(info.statistics.total_unresolved_relations)
+            )
+            stats_table.add_row("Isolated Entities", str(info.statistics.isolated_entities))
+
+            console.print(stats_table)
+
+            # Entity types
+            if info.statistics.entity_types:
+                entity_types_table = Table(title="📑 Entity Types")
+                entity_types_table.add_column("Type", style="blue")
+                entity_types_table.add_column("Count", style="green")
+
+                for entity_type, count in info.statistics.entity_types.items():
+                    entity_types_table.add_row(entity_type, str(count))
+
+                console.print(entity_types_table)
+
+            # Most connected entities
+            if info.statistics.most_connected_entities:
+                connected_table = Table(title="🔗 Most Connected Entities")
+                connected_table.add_column("Title", style="blue")
+                connected_table.add_column("Permalink", style="cyan")
+                connected_table.add_column("Relations", style="green")
+
+                for entity in info.statistics.most_connected_entities:
+                    connected_table.add_row(
+                        entity["title"], entity["permalink"], str(entity["relation_count"])
+                    )
+
+                console.print(connected_table)
+
+            # Recent activity
+            if info.activity.recently_updated:
+                recent_table = Table(title="🕒 Recent Activity")
+                recent_table.add_column("Title", style="blue")
+                recent_table.add_column("Type", style="cyan")
+                recent_table.add_column("Last Updated", style="green")
+
+                for entity in info.activity.recently_updated[:5]:  # Show top 5
+                    updated_at = (
+                        datetime.fromisoformat(entity["updated_at"])
+                        if isinstance(entity["updated_at"], str)
+                        else entity["updated_at"]
+                    )
+                    recent_table.add_row(
+                        entity["title"],
+                        entity["entity_type"],
+                        updated_at.strftime("%Y-%m-%d %H:%M"),
+                    )
+
+                console.print(recent_table)
+
+            # System status
+            system_tree = Tree("🖥️ System Status")
+            system_tree.add(f"Basic Memory version: [bold green]{info.system.version}[/bold green]")
+            system_tree.add(
+                f"Database: [cyan]{info.system.database_path}[/cyan] ([green]{info.system.database_size}[/green])"
+            )
+
+            # Watch status
+            if info.system.watch_status:  # pragma: no cover
+                watch_branch = system_tree.add("Watch Service")
+                running = info.system.watch_status.get("running", False)
+                status_color = "green" if running else "red"
+                watch_branch.add(
+                    f"Status: [bold {status_color}]{'Running' if running else 'Stopped'}[/bold {status_color}]"
+                )
+
+                if running:
+                    start_time = (
+                        datetime.fromisoformat(info.system.watch_status.get("start_time", ""))
+                        if isinstance(info.system.watch_status.get("start_time"), str)
+                        else info.system.watch_status.get("start_time")
+                    )
+                    watch_branch.add(
+                        f"Running since: [cyan]{start_time.strftime('%Y-%m-%d %H:%M')}[/cyan]"
+                    )
+                    watch_branch.add(
+                        f"Files synced: [green]{info.system.watch_status.get('synced_files', 0)}[/green]"
+                    )
+                    watch_branch.add(
+                        f"Errors: [{'red' if info.system.watch_status.get('error_count', 0) > 0 else 'green'}]{info.system.watch_status.get('error_count', 0)}[/{'red' if info.system.watch_status.get('error_count', 0) > 0 else 'green'}]"
+                    )
+            else:
+                system_tree.add("[yellow]Watch service not running[/yellow]")
+
+            console.print(system_tree)
+
+            # Available projects
+            projects_table = Table(title="📁 Available Projects")
+            projects_table.add_column("Name", style="blue")
+            projects_table.add_column("Path", style="cyan")
+            projects_table.add_column("Default", style="green")
+
+            for name, path in info.available_projects.items():
+                is_default = name == info.default_project
+                projects_table.add_row(name, path, "✓" if is_default else "")
+
+            console.print(projects_table)
+
+            # Timestamp
+            current_time = (
+                datetime.fromisoformat(str(info.system.timestamp))
+                if isinstance(info.system.timestamp, str)
+                else info.system.timestamp
+            )
+            console.print(f"\nTimestamp: [cyan]{current_time.strftime('%Y-%m-%d %H:%M:%S')}[/cyan]")
+
+    except Exception as e:  # pragma: no cover
+        typer.echo(f"Error getting project info: {e}", err=True)
+        raise typer.Exit(1)

basic_memory/cli/commands/status.py

@@ -3,7 +3,6 @@
 import asyncio
 from typing import Set, Dict
 
-import logfire
 import typer
 from loguru import logger
 from rich.console import Console
@@ -134,11 +133,10 @@ def status(
     verbose: bool = typer.Option(False, "--verbose", "-v", help="Show detailed file information"),
 ):
     """Show sync status between files and database."""
-    with logfire.span("status"):  # pyright: ignore [reportGeneralTypeIssues]
-        try:
-            sync_service = asyncio.run(get_sync_service())
-            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(code=1)  # pragma: no cover
+    try:
+        sync_service = asyncio.run(get_sync_service())
+        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(code=1)  # pragma: no cover

basic_memory/cli/commands/sync.py

@@ -93,8 +93,10 @@ def group_issues_by_directory(issues: List[ValidationIssue]) -> Dict[str, List[V
 def display_sync_summary(knowledge: SyncReport):
     """Display a one-line summary of sync changes."""
     total_changes = knowledge.total
+    project_name = config.project
+
     if total_changes == 0:
-        console.print("[green]Everything up to date[/green]")
+        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)"
@@ -113,16 +115,18 @@ def display_sync_summary(knowledge: SyncReport):
     if del_count:
         changes.append(f"[red]{del_count} deleted[/red]")
 
-    console.print(f"Synced {total_changes} files ({', '.join(changes)})")
+    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."""
+    project_name = config.project
+
     if knowledge.total == 0:
-        console.print("\n[green]Everything up to date[/green]")
+        console.print(f"\n[green]Project '{project_name}': Everything up to date[/green]")
         return
 
-    console.print("\n[bold]Sync Results[/bold]")
+    console.print(f"\n[bold]Sync Results for Project '{project_name}'[/bold]")
 
     if knowledge.total > 0:
         knowledge_tree = Tree("[bold]Knowledge Files[/bold]")
@@ -150,23 +154,52 @@ def display_detailed_sync_results(knowledge: SyncReport):
 
 async def run_sync(verbose: bool = False, watch: bool = False, console_status: bool = False):
     """Run sync operation."""
+    import time
+
+    start_time = time.time()
+
+    logger.info(
+        "Sync command started",
+        project=config.project,
+        watch_mode=watch,
+        verbose=verbose,
+        directory=str(config.home),
+    )
 
     sync_service = await get_sync_service()
 
     # Start watching if requested
     if watch:
+        logger.info("Starting watch service after initial sync")
         watch_service = WatchService(
             sync_service=sync_service,
             file_service=sync_service.entity_service.file_service,
             config=config,
         )
-        # full sync
-        await sync_service.sync(config.home)
+
+        # full sync - no progress bars in watch mode
+        await sync_service.sync(config.home, show_progress=False)
+
         # watch changes
         await watch_service.run()  # pragma: no cover
     else:
-        # one time sync
-        knowledge_changes = await sync_service.sync(config.home)
+        # one time sync - use progress bars for better UX
+        logger.info("Running one-time sync")
+        knowledge_changes = await sync_service.sync(config.home, show_progress=True)
+
+        # 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)
@@ -191,12 +224,24 @@ def sync(
 ) -> None:
     """Sync knowledge files with the database."""
     try:
+        # Show which project we're syncing
+        if not watch:  # Don't show in watch mode as it would break the UI
+            typer.echo(f"Syncing project: {config.project}")
+            typer.echo(f"Project path: {config.home}")
+
         # Run sync
         asyncio.run(run_sync(verbose=verbose, watch=watch))
 
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
-            logger.exception("Sync failed", e)
+            logger.exception(
+                "Sync command failed",
+                project=config.project,
+                error=str(e),
+                error_type=type(e).__name__,
+                watch_mode=watch,
+                directory=str(config.home),
+            )
             typer.echo(f"Error during sync: {e}", err=True)
             raise typer.Exit(1)
         raise

basic_memory/cli/commands/{tools.py → tool.py}

@@ -1,6 +1,7 @@
 """CLI tool commands for Basic Memory."""
 
 import asyncio
+import sys
 from typing import Optional, List, Annotated
 
 import typer
@@ -9,7 +10,6 @@ from rich import print as rprint
 
 from basic_memory.cli.app import app
 from basic_memory.mcp.tools import build_context as mcp_build_context
-from basic_memory.mcp.tools import get_entity as mcp_get_entity
 from basic_memory.mcp.tools import read_note as mcp_read_note
 from basic_memory.mcp.tools import recent_activity as mcp_recent_activity
 from basic_memory.mcp.tools import search as mcp_search
@@ -20,24 +20,78 @@ from basic_memory.mcp.prompts.continue_conversation import (
     continue_conversation as mcp_continue_conversation,
 )
 
+from basic_memory.mcp.prompts.recent_activity import (
+    recent_activity_prompt as recent_activity_prompt,
+)
+
 from basic_memory.schemas.base import TimeFrame
 from basic_memory.schemas.memory import MemoryUrl
 from basic_memory.schemas.search import SearchQuery, SearchItemType
 
 tool_app = typer.Typer()
-app.add_typer(tool_app, name="tools", help="cli versions mcp tools")
+app.add_typer(tool_app, name="tool", help="Direct access to MCP tools via CLI")
 
 
 @tool_app.command()
 def write_note(
     title: Annotated[str, typer.Option(help="The title of the note")],
-    content: Annotated[str, typer.Option(help="The content of the note")],
     folder: Annotated[str, typer.Option(help="The folder to create the note in")],
+    content: Annotated[
+        Optional[str],
+        typer.Option(
+            help="The content of the note. If not provided, content will be read from stdin. This allows piping content from other commands, e.g.: cat file.md | basic-memory tools write-note"
+        ),
+    ] = None,
     tags: Annotated[
         Optional[List[str]], typer.Option(help="A list of tags to apply to the note")
     ] = None,
 ):
+    """Create or update a markdown note. Content can be provided as an argument or read from stdin.
+
+    Content can be provided in two ways:
+    1. Using the --content parameter
+    2. Piping content through stdin (if --content is not provided)
+
+    Examples:
+
+    # Using content parameter
+    basic-memory tools write-note --title "My Note" --folder "notes" --content "Note content"
+
+    # Using stdin pipe
+    echo "# My Note Content" | basic-memory tools write-note --title "My Note" --folder "notes"
+
+    # Using heredoc
+    cat << EOF | basic-memory tools write-note --title "My Note" --folder "notes"
+    # My Document
+
+    This is my document content.
+
+    - Point 1
+    - Point 2
+    EOF
+
+    # Reading from a file
+    cat document.md | basic-memory tools write-note --title "Document" --folder "docs"
+    """
     try:
+        # If content is not provided, read from stdin
+        if content is None:
+            # Check if we're getting data from a pipe or redirect
+            if not sys.stdin.isatty():
+                content = sys.stdin.read()
+            else:  # pragma: no cover
+                # If stdin is a terminal (no pipe/redirect), inform the user
+                typer.echo(
+                    "No content provided. Please provide content via --content or by piping to stdin.",
+                    err=True,
+                )
+                raise typer.Exit(1)
+
+        # Also check for empty content
+        if content is not None and not content.strip():
+            typer.echo("Empty content provided. Please provide non-empty content.", err=True)
+            raise typer.Exit(1)
+
         note = asyncio.run(mcp_write_note(title, content, folder, tags))
         rprint(note)
     except Exception as e:  # pragma: no cover
@@ -79,7 +133,11 @@ def build_context(
                 max_related=max_related,
             )
         )
-        rprint(context.model_dump_json(indent=2))
+        # 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))
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
             typer.echo(f"Error during build_context: {e}", err=True)
@@ -107,7 +165,11 @@ def recent_activity(
                 max_related=max_related,
             )
         )
-        rprint(context.model_dump_json(indent=2))
+        # 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))
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
             typer.echo(f"Error during build_context: {e}", err=True)
@@ -139,7 +201,11 @@ def search(
             after_date=after_date,
         )
         results = asyncio.run(mcp_search(query=search_query, page=page, page_size=page_size))
-        rprint(results.model_dump_json(indent=2))
+        # Use json module for more controlled serialization
+        import json
+
+        results_dict = results.model_dump(exclude_none=True)
+        print(json.dumps(results_dict, indent=2, ensure_ascii=True, default=str))
     except Exception as e:  # pragma: no cover
         if not isinstance(e, typer.Exit):
             logger.exception("Error during search", e)
@@ -148,18 +214,6 @@ def search(
         raise
 
 
-@tool_app.command()
-def get_entity(identifier: str):
-    try:
-        entity = asyncio.run(mcp_get_entity(identifier=identifier))
-        rprint(entity.model_dump_json(indent=2))
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during get_entity: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
 @tool_app.command(name="continue-conversation")
 def continue_conversation(
     topic: Annotated[Optional[str], typer.Option(help="Topic or keyword to search for")] = None,
@@ -167,7 +221,7 @@ def continue_conversation(
         Optional[str], typer.Option(help="How far back to look for activity")
     ] = None,
 ):
-    """Continue a previous conversation or work session."""
+    """Prompt to continue a previous conversation or work session."""
     try:
         # Prompt functions return formatted strings directly
         session = asyncio.run(mcp_continue_conversation(topic=topic, timeframe=timeframe))
@@ -178,3 +232,22 @@ def continue_conversation(
             typer.echo(f"Error continuing conversation: {e}", err=True)
             raise typer.Exit(1)
         raise
+
+
+# @tool_app.command(name="show-recent-activity")
+# def show_recent_activity(
+#     timeframe: Annotated[
+#         str, typer.Option(help="How far back to look for activity")
+#     ] = "7d",
+# ):
+#     """Prompt to show recent activity."""
+#     try:
+#         # Prompt functions return formatted strings directly
+#         session = asyncio.run(recent_activity_prompt(timeframe=timeframe))
+#         rprint(session)
+#     except Exception as e:  # pragma: no cover
+#         if not isinstance(e, typer.Exit):
+#             logger.exception("Error continuing conversation", e)
+#             typer.echo(f"Error continuing conversation: {e}", err=True)
+#             raise typer.Exit(1)
+#         raise

basic_memory/cli/main.py

@@ -1,6 +1,7 @@
 """Main CLI entry point for basic-memory."""  # pragma: no cover
 
 from basic_memory.cli.app import app  # pragma: no cover
+import typer
 
 # Register commands
 from basic_memory.cli.commands import (  # noqa: F401  # pragma: no cover
@@ -12,8 +13,46 @@ from basic_memory.cli.commands import (  # noqa: F401  # pragma: no cover
     import_claude_conversations,
     import_claude_projects,
     import_chatgpt,
-    tools,
+    tool,
+    project,
 )
 
+
+# Version command
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    project: str = typer.Option(  # noqa
+        "main",
+        "--project",
+        "-p",
+        help="Specify which project to use",
+        envvar="BASIC_MEMORY_PROJECT",
+    ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show version information and exit.",
+        is_eager=True,
+    ),
+):
+    """Basic Memory - Local-first personal knowledge management system."""
+    if version:  # pragma: no cover
+        from basic_memory import __version__
+        from basic_memory.config import config
+
+        typer.echo(f"Basic Memory v{__version__}")
+        typer.echo(f"Current project: {config.project}")
+        typer.echo(f"Project path: {config.home}")
+        raise typer.Exit()
+
+    # Handle project selection via environment variable
+    if project:
+        import os
+
+        os.environ["BASIC_MEMORY_PROJECT"] = project
+
+
 if __name__ == "__main__":  # pragma: no cover
     app()