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

basic_memory/cli/commands/sync.py

@@ -1,206 +0,0 @@
-"""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
-
-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 config
-from basic_memory.markdown import EntityParser
-from basic_memory.markdown.markdown_processor import MarkdownProcessor
-from basic_memory.repository import (
-    EntityRepository,
-    ObservationRepository,
-    RelationRepository,
-)
-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, FileChangeScanner
-from basic_memory.sync.utils import SyncReport
-from basic_memory.sync.watch_service import WatchService
-
-console = Console()
-
-
-@dataclass
-class ValidationIssue:
-    file_path: str
-    error: str
-
-
-async def get_sync_service():  # pragma: no cover
-    """Get sync service instance with all dependencies."""
-    _, session_maker = await db.get_or_create_db(
-        db_path=config.database_path, db_type=db.DatabaseType.FILESYSTEM
-    )
-
-    entity_parser = EntityParser(config.home)
-    markdown_processor = MarkdownProcessor(entity_parser)
-    file_service = FileService(config.home, markdown_processor)
-
-    # Initialize repositories
-    entity_repository = EntityRepository(session_maker)
-    observation_repository = ObservationRepository(session_maker)
-    relation_repository = RelationRepository(session_maker)
-    search_repository = SearchRepository(session_maker)
-
-    # Initialize services
-    search_service = SearchService(search_repository, entity_repository, file_service)
-    link_resolver = LinkResolver(entity_repository, search_service)
-
-    # Initialize scanner
-    file_change_scanner = FileChangeScanner(entity_repository)
-
-    # Initialize services
-    entity_service = EntityService(
-        entity_parser,
-        entity_repository,
-        observation_repository,
-        relation_repository,
-        file_service,
-        link_resolver,
-    )
-
-    # Create sync service
-    sync_service = SyncService(
-        scanner=file_change_scanner,
-        entity_service=entity_service,
-        entity_parser=entity_parser,
-        entity_repository=entity_repository,
-        relation_repository=relation_repository,
-        search_service=search_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."""
-    total_changes = knowledge.total_changes
-    if total_changes == 0:
-        console.print("[green]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"Synced {total_changes} files ({', '.join(changes)})")
-
-
-def display_detailed_sync_results(knowledge: SyncReport):
-    """Display detailed sync results with trees."""
-    if knowledge.total_changes == 0:
-        console.print("\n[green]Everything up to date[/green]")
-        return
-
-    console.print("\n[bold]Sync Results[/bold]")
-
-    if knowledge.total_changes > 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, watch: bool = False, console_status: bool = False):
-    """Run sync operation."""
-
-    sync_service = await get_sync_service()
-
-    # Start watching if requested
-    if watch:
-        watch_service = WatchService(
-            sync_service=sync_service,
-            file_service=sync_service.entity_service.file_service,
-            config=config,
-        )
-        await watch_service.handle_changes(config.home)
-        await watch_service.run(console_status=console_status)  # pragma: no cover
-    else:
-        # one time sync
-        knowledge_changes = await sync_service.sync(config.home)
-        # Display results
-        if verbose:
-            display_detailed_sync_results(knowledge_changes)
-        else:
-            display_sync_summary(knowledge_changes)  # pragma: no cover
-
-
-@app.command()
-def sync(
-    verbose: bool = typer.Option(
-        False,
-        "--verbose",
-        "-v",
-        help="Show detailed sync information.",
-    ),
-    watch: bool = typer.Option(
-        False,
-        "--watch",
-        "-w",
-        help="Start watching for changes after sync.",
-    ),
-    console_status: bool = typer.Option(
-        False, "--console-status", "-c", help="Show live console status"
-    ),
-) -> None:
-    """Sync knowledge files with the database."""
-    try:
-        # Run sync
-        asyncio.run(run_sync(verbose=verbose, watch=watch, console_status=console_status))
-
-    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)
-            raise typer.Exit(1)
-        raise

basic_memory/cli/commands/tools.py

@@ -1,157 +0,0 @@
-"""Database management commands."""
-
-import asyncio
-from typing import Optional, List, Annotated
-
-import typer
-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
-from basic_memory.mcp.tools import write_note as mcp_write_note
-from basic_memory.schemas.base import TimeFrame
-from basic_memory.schemas.memory import MemoryUrl
-from basic_memory.schemas.search import SearchQuery
-
-tool_app = typer.Typer()
-app.add_typer(tool_app, name="tools", help="cli versions mcp tools")
-
-
-@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")],
-    tags: Annotated[
-        Optional[List[str]], typer.Option(help="A list of tags to apply to the note")
-    ] = None,
-):
-    try:
-        note = asyncio.run(mcp_write_note(title, content, folder, tags))
-        rprint(note)
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during write_note: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
-@tool_app.command()
-def read_note(identifier: str, page: int = 1, page_size: int = 10):
-    try:
-        note = asyncio.run(mcp_read_note(identifier, page, page_size))
-        rprint(note)
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during read_note: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
-@tool_app.command()
-def build_context(
-    url: MemoryUrl,
-    depth: Optional[int] = 1,
-    timeframe: Optional[TimeFrame] = "7d",
-    page: int = 1,
-    page_size: int = 10,
-    max_related: int = 10,
-):
-    try:
-        context = asyncio.run(
-            mcp_build_context(
-                url=url,
-                depth=depth,
-                timeframe=timeframe,
-                page=page,
-                page_size=page_size,
-                max_related=max_related,
-            )
-        )
-        rprint(context.model_dump())
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during build_context: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
-@tool_app.command()
-def recent_activity(
-    type: Annotated[Optional[List[str]], typer.Option()] = ["entity", "observation", "relation"],
-    depth: Optional[int] = 1,
-    timeframe: Optional[TimeFrame] = "7d",
-    page: int = 1,
-    page_size: int = 10,
-    max_related: int = 10,
-):
-    assert type is not None, "type is required"
-    if any(t not in ["entity", "observation", "relation"] for t in type):  # pragma: no cover
-        print("type must be one of ['entity', 'observation', 'relation']")
-        raise typer.Abort()
-
-    try:
-        context = asyncio.run(
-            mcp_recent_activity(
-                type=type,  # pyright: ignore [reportArgumentType]
-                depth=depth,
-                timeframe=timeframe,
-                page=page,
-                page_size=page_size,
-                max_related=max_related,
-            )
-        )
-        rprint(context.model_dump())
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during build_context: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
-@tool_app.command()
-def search(
-    query: str,
-    permalink: Annotated[bool, typer.Option("--permalink", help="Search permalink values")] = False,
-    title: Annotated[bool, typer.Option("--title", help="Search title values")] = False,
-    after_date: Annotated[
-        Optional[str],
-        typer.Option("--after_date", help="Search results after date, eg. '2d', '1 week'"),
-    ] = None,
-    page: int = 1,
-    page_size: int = 10,
-):
-    if permalink and title:  # pragma: no cover
-        print("Cannot search both permalink and title")
-        raise typer.Abort()
-
-    try:
-        search_query = SearchQuery(
-            permalink_match=query if permalink else None,
-            text=query if query else None,
-            title=query if title else None,
-            after_date=after_date,
-        )
-        results = asyncio.run(mcp_search(query=search_query, page=page, page_size=page_size))
-        rprint(results.model_dump())
-    except Exception as e:  # pragma: no cover
-        if not isinstance(e, typer.Exit):
-            typer.echo(f"Error during search: {e}", err=True)
-            raise typer.Exit(1)
-        raise
-
-
-@tool_app.command()
-def get_entity(identifier: str):
-    try:
-        entity = asyncio.run(mcp_get_entity(identifier=identifier))
-        rprint(entity.model_dump())
-    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

basic_memory/mcp/tools/knowledge.py

@@ -1,68 +0,0 @@
-"""Knowledge graph management tools for Basic Memory MCP server."""
-
-import logfire
-
-from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.utils import call_get, call_post
-from basic_memory.schemas.memory import memory_url_path
-from basic_memory.schemas.request import (
-    GetEntitiesRequest,
-)
-from basic_memory.schemas.delete import (
-    DeleteEntitiesRequest,
-)
-from basic_memory.schemas.response import EntityListResponse, EntityResponse, DeleteEntitiesResponse
-from basic_memory.mcp.async_client import client
-
-
-@mcp.tool(
-    description="Get complete information about a specific entity including observations and relations",
-)
-async def get_entity(identifier: str) -> EntityResponse:
-    """Get a specific entity info by its permalink.
-
-    Args:
-        identifier: Path identifier for the entity
-    """
-    with logfire.span("Getting entity", permalink=identifier):  # pyright: ignore [reportGeneralTypeIssues]
-        permalink = memory_url_path(identifier)
-        url = f"/knowledge/entities/{permalink}"
-        response = await call_get(client, url)
-        return EntityResponse.model_validate(response.json())
-
-
-@mcp.tool(
-    description="Load multiple entities by their permalinks in a single request",
-)
-async def get_entities(request: GetEntitiesRequest) -> EntityListResponse:
-    """Load multiple entities by their permalinks.
-
-    Args:
-        request: OpenNodesRequest containing list of permalinks to load
-
-    Returns:
-        EntityListResponse containing complete details for each requested entity
-    """
-    with logfire.span("Getting multiple entities", permalink_count=len(request.permalinks)):  # pyright: ignore [reportGeneralTypeIssues]
-        url = "/knowledge/entities"
-        response = await call_get(
-            client,
-            url,
-            params=[
-                ("permalink", memory_url_path(identifier)) for identifier in request.permalinks
-            ],
-        )
-        return EntityListResponse.model_validate(response.json())
-
-
-@mcp.tool(
-    description="Permanently delete entities and all related content (observations and relations)",
-)
-async def delete_entities(request: DeleteEntitiesRequest) -> DeleteEntitiesResponse:
-    """Delete entities from the knowledge graph."""
-    with logfire.span("Deleting entities", permalink_count=len(request.permalinks)):  # pyright: ignore [reportGeneralTypeIssues]
-        url = "/knowledge/entities/delete"
-
-        request.permalinks = [memory_url_path(permlink) for permlink in request.permalinks]
-        response = await call_post(client, url, json=request.model_dump())
-        return DeleteEntitiesResponse.model_validate(response.json())

basic_memory/mcp/tools/memory.py

@@ -1,170 +0,0 @@
-"""Discussion context tools for Basic Memory MCP server."""
-
-from typing import Optional, Literal, List
-
-from loguru import logger
-import logfire
-
-from basic_memory.mcp.async_client import client
-from basic_memory.mcp.server import mcp
-from basic_memory.mcp.tools.utils import call_get
-from basic_memory.schemas.memory import (
-    GraphContext,
-    MemoryUrl,
-    memory_url_path,
-    normalize_memory_url,
-)
-from basic_memory.schemas.base import TimeFrame
-
-
-@mcp.tool(
-    description="""Build context from a memory:// URI to continue conversations naturally.
-    
-    Use this to follow up on previous discussions or explore related topics.
-    Timeframes support natural language like:
-    - "2 days ago"
-    - "last week" 
-    - "today"
-    - "3 months ago"
-    Or standard formats like "7d", "24h"
-    """,
-)
-async def build_context(
-    url: MemoryUrl,
-    depth: Optional[int] = 1,
-    timeframe: Optional[TimeFrame] = "7d",
-    page: int = 1,
-    page_size: int = 10,
-    max_related: int = 10,
-) -> GraphContext:
-    """Get context needed to continue a discussion.
-
-    This tool enables natural continuation of discussions by loading relevant context
-    from memory:// URIs. It uses pattern matching to find relevant content and builds
-    a rich context graph of related information.
-
-    Args:
-        url: memory:// URI pointing to discussion content (e.g. memory://specs/search)
-        depth: How many relation hops to traverse (1-3 recommended for performance)
-        timeframe: How far back to look. Supports natural language like "2 days ago", "last week"
-        page: Page number of results to return (default: 1)
-        page_size: Number of results to return per page (default: 10)
-        max_related: Maximum number of related results to return (default: 10)
-
-    Returns:
-        GraphContext containing:
-            - primary_results: Content matching the memory:// URI
-            - related_results: Connected content via relations
-            - metadata: Context building details
-
-    Examples:
-        # Continue a specific discussion
-        build_context("memory://specs/search")
-
-        # Get deeper context about a component
-        build_context("memory://components/memory-service", depth=2)
-
-        # Look at recent changes to a specification
-        build_context("memory://specs/document-format", timeframe="today")
-
-        # Research the history of a feature
-        build_context("memory://features/knowledge-graph", timeframe="3 months ago")
-    """
-    with logfire.span("Building context", url=url, depth=depth, timeframe=timeframe):  # pyright: ignore [reportGeneralTypeIssues]
-        logger.info(f"Building context from {url}")
-        url = normalize_memory_url(url)
-        response = await call_get(
-            client,
-            f"/memory/{memory_url_path(url)}",
-            params={
-                "depth": depth,
-                "timeframe": timeframe,
-                "page": page,
-                "page_size": page_size,
-                "max_related": max_related,
-            },
-        )
-        return GraphContext.model_validate(response.json())
-
-
-@mcp.tool(
-    description="""Get recent activity from across the knowledge base.
-    
-    Timeframe supports natural language formats like:
-    - "2 days ago"  
-    - "last week"
-    - "yesterday" 
-    - "today"
-    - "3 weeks ago"
-    Or standard formats like "7d"
-    """,
-)
-async def recent_activity(
-    type: List[Literal["entity", "observation", "relation"]] = [],
-    depth: Optional[int] = 1,
-    timeframe: Optional[TimeFrame] = "7d",
-    page: int = 1,
-    page_size: int = 10,
-    max_related: int = 10,
-) -> GraphContext:
-    """Get recent activity across the knowledge base.
-
-    Args:
-        type: Filter by content type(s). Valid options:
-            - ["entity"] for knowledge entities
-            - ["relation"] for connections between entities
-            - ["observation"] for notes and observations
-            Multiple types can be combined: ["entity", "relation"]
-        depth: How many relation hops to traverse (1-3 recommended)
-        timeframe: Time window to search. Supports natural language:
-            - Relative: "2 days ago", "last week", "yesterday"
-            - Points in time: "2024-01-01", "January 1st"
-            - Standard format: "7d", "24h"
-        page: Page number of results to return (default: 1)
-        page_size: Number of results to return per page (default: 10)
-        max_related: Maximum number of related results to return (default: 10)
-
-    Returns:
-        GraphContext containing:
-            - primary_results: Latest activities matching the filters
-            - related_results: Connected content via relations
-            - metadata: Query details and statistics
-
-    Examples:
-        # Get all entities for the last 10 days (default)
-        recent_activity()
-
-        # Get all entities from yesterday
-        recent_activity(type=["entity"], timeframe="yesterday")
-
-        # Get recent relations and observations
-        recent_activity(type=["relation", "observation"], timeframe="today")
-
-        # Look back further with more context
-        recent_activity(type=["entity"], depth=2, timeframe="2 weeks ago")
-
-    Notes:
-        - Higher depth values (>3) may impact performance with large result sets
-        - For focused queries, consider using build_context with a specific URI
-        - Max timeframe is 1 year in the past
-    """
-    with logfire.span("Getting recent activity", type=type, depth=depth, timeframe=timeframe):  # pyright: ignore [reportGeneralTypeIssues]
-        logger.info(
-            f"Getting recent activity from {type}, depth={depth}, timeframe={timeframe}, page={page}, page_size={page_size}, max_related={max_related}"
-        )
-        params = {
-            "depth": depth,
-            "timeframe": timeframe,
-            "page": page,
-            "page_size": page_size,
-            "max_related": max_related,
-        }
-        if type:
-            params["type"] = type
-
-        response = await call_get(
-            client,
-            "/memory/recent",
-            params=params,
-        )
-        return GraphContext.model_validate(response.json())