basic-memory 0.12.2__py3-none-any.whl → 0.13.0__py3-none-any.whl

basic_memory/mcp/tools/sync_status.py

@@ -0,0 +1,254 @@
+"""Sync status tool for Basic Memory MCP server."""
+
+from typing import Optional
+
+from loguru import logger
+
+from basic_memory.mcp.server import mcp
+from basic_memory.mcp.project_session import get_active_project
+
+
+def _get_all_projects_status() -> list[str]:
+    """Get status lines for all configured projects."""
+    status_lines = []
+
+    try:
+        from basic_memory.config import app_config
+        from basic_memory.services.sync_status_service import sync_status_tracker
+
+        if app_config.projects:
+            status_lines.extend(["", "---", "", "**All Projects Status:**"])
+
+            for project_name, project_path in app_config.projects.items():
+                # Check if this project has sync status
+                project_sync_status = sync_status_tracker.get_project_status(project_name)
+
+                if project_sync_status:
+                    # Project has tracked sync activity
+                    if project_sync_status.status.value == "watching":
+                        # Project is actively watching for changes (steady state)
+                        status_icon = "👁️"
+                        status_text = "Watching for changes"
+                    elif project_sync_status.status.value == "completed":
+                        # Sync completed but not yet watching - transitional state
+                        status_icon = "✅"
+                        status_text = "Sync completed"
+                    elif project_sync_status.status.value in ["scanning", "syncing"]:
+                        status_icon = "🔄"
+                        status_text = "Sync in progress"
+                        if project_sync_status.files_total > 0:
+                            progress_pct = (
+                                project_sync_status.files_processed
+                                / project_sync_status.files_total
+                            ) * 100
+                            status_text += f" ({project_sync_status.files_processed}/{project_sync_status.files_total}, {progress_pct:.0f}%)"
+                    elif project_sync_status.status.value == "failed":
+                        status_icon = "❌"
+                        status_text = f"Sync error: {project_sync_status.error or 'Unknown error'}"
+                    else:
+                        status_icon = "⏸️"
+                        status_text = project_sync_status.status.value.title()
+                else:
+                    # Project has no tracked sync activity - will be synced automatically
+                    status_icon = "⏳"
+                    status_text = "Pending sync"
+
+                status_lines.append(f"- {status_icon} **{project_name}**: {status_text}")
+
+    except Exception as e:
+        logger.debug(f"Could not get project config for comprehensive status: {e}")
+
+    return status_lines
+
+
+@mcp.tool(
+    description="""Check the status of file synchronization and background operations.
+    
+    Use this tool to:
+    - Check if file sync is in progress or completed
+    - Get detailed sync progress information  
+    - Understand if your files are fully indexed
+    - Get specific error details if sync operations failed
+    - Monitor initial project setup and legacy migration
+    
+    This covers all sync operations including:
+    - Initial project setup and file indexing
+    - Legacy project migration to unified database
+    - Ongoing file monitoring and updates
+    - Background processing of knowledge graphs
+    """,
+)
+async def sync_status(project: Optional[str] = None) -> str:
+    """Get current sync status and system readiness information.
+
+    This tool provides detailed information about any ongoing or completed
+    sync operations, helping users understand when their files are ready.
+
+    Args:
+        project: Optional project name to get project-specific context
+
+    Returns:
+        Formatted sync status with progress, readiness, and guidance
+    """
+    logger.info("MCP tool call tool=sync_status")
+
+    status_lines = []
+
+    try:
+        from basic_memory.services.sync_status_service import sync_status_tracker
+
+        # Get overall summary
+        summary = sync_status_tracker.get_summary()
+        is_ready = sync_status_tracker.is_ready
+
+        # Header
+        status_lines.extend(
+            [
+                "# Basic Memory Sync Status",
+                "",
+                f"**Current Status**: {summary}",
+                f"**System Ready**: {'✅ Yes' if is_ready else '🔄 Processing'}",
+                "",
+            ]
+        )
+
+        if is_ready:
+            status_lines.extend(
+                [
+                    "✅ **All sync operations completed**",
+                    "",
+                    "- File indexing is complete",
+                    "- Knowledge graphs are up to date",
+                    "- All Basic Memory tools are fully operational",
+                    "",
+                    "Your knowledge base is ready for use!",
+                ]
+            )
+
+            # Show all projects status even when ready
+            status_lines.extend(_get_all_projects_status())
+        else:
+            # System is still processing - show both active and all projects
+            all_sync_projects = sync_status_tracker.get_all_projects()
+
+            active_projects = [
+                p for p in all_sync_projects.values() if p.status.value in ["scanning", "syncing"]
+            ]
+            failed_projects = [p for p in all_sync_projects.values() if p.status.value == "failed"]
+
+            if active_projects:
+                status_lines.extend(
+                    [
+                        "🔄 **File synchronization in progress**",
+                        "",
+                        "Basic Memory is automatically processing all configured projects and building knowledge graphs.",
+                        "This typically takes 1-3 minutes depending on the amount of content.",
+                        "",
+                        "**Currently Processing:**",
+                    ]
+                )
+
+                for project_status in active_projects:
+                    progress = ""
+                    if project_status.files_total > 0:
+                        progress_pct = (
+                            project_status.files_processed / project_status.files_total
+                        ) * 100
+                        progress = f" ({project_status.files_processed}/{project_status.files_total}, {progress_pct:.0f}%)"
+
+                    status_lines.append(
+                        f"- **{project_status.project_name}**: {project_status.message}{progress}"
+                    )
+
+                status_lines.extend(
+                    [
+                        "",
+                        "**What's happening:**",
+                        "- Scanning and indexing markdown files",
+                        "- Building entity and relationship graphs",
+                        "- Setting up full-text search indexes",
+                        "- Processing file changes and updates",
+                        "",
+                        "**What you can do:**",
+                        "- Wait for automatic processing to complete - no action needed",
+                        "- Use this tool again to check progress",
+                        "- Simple operations may work already",
+                        "- All projects will be available once sync finishes",
+                    ]
+                )
+
+            # Handle failed projects (independent of active projects)
+            if failed_projects:
+                status_lines.extend(["", "❌ **Some projects failed to sync:**", ""])
+
+                for project_status in failed_projects:
+                    status_lines.append(
+                        f"- **{project_status.project_name}**: {project_status.error or 'Unknown error'}"
+                    )
+
+                status_lines.extend(
+                    [
+                        "",
+                        "**Next steps:**",
+                        "1. Check the logs for detailed error information",
+                        "2. Ensure file permissions allow read/write access",
+                        "3. Try restarting the MCP server",
+                        "4. If issues persist, consider filing a support issue",
+                    ]
+                )
+            elif not active_projects:
+                # No active or failed projects - must be pending
+                status_lines.extend(
+                    [
+                        "⏳ **Sync operations pending**",
+                        "",
+                        "File synchronization has been queued but hasn't started yet.",
+                        "This usually resolves automatically within a few seconds.",
+                    ]
+                )
+
+        # Add comprehensive project status for all configured projects
+        all_projects_status = _get_all_projects_status()
+        if all_projects_status:
+            status_lines.extend(all_projects_status)
+
+            # Add explanation about automatic syncing if there are unsynced projects
+            unsynced_count = sum(1 for line in all_projects_status if "⏳" in line)
+            if unsynced_count > 0 and not is_ready:
+                status_lines.extend(
+                    [
+                        "",
+                        "**Note**: All configured projects will be automatically synced during startup.",
+                        "You don't need to manually switch projects - Basic Memory handles this for you.",
+                    ]
+                )
+
+        # Add project context if provided
+        if project:
+            try:
+                active_project = get_active_project(project)
+                status_lines.extend(
+                    [
+                        "",
+                        "---",
+                        "",
+                        f"**Active Project**: {active_project.name}",
+                        f"**Project Path**: {active_project.home}",
+                    ]
+                )
+            except Exception as e:
+                logger.debug(f"Could not get project info: {e}")
+
+        return "\n".join(status_lines)
+
+    except Exception as e:
+        return f"""# Sync Status - Error
+
+❌ **Unable to check sync status**: {str(e)}
+
+**Troubleshooting:**
+- The system may still be starting up
+- Try waiting a few seconds and checking again  
+- Check logs for detailed error information
+- Consider restarting if the issue persists
+"""

basic_memory/mcp/tools/utils.py

@@ -5,6 +5,7 @@ to the Basic Memory API, with improved error handling and logging.
 """
 
 import typing
+from typing import Optional
 
 from httpx import Response, URL, AsyncClient, HTTPStatusError
 from httpx._client import UseClientDefault, USE_CLIENT_DEFAULT
@@ -23,7 +24,9 @@ from loguru import logger
 from mcp.server.fastmcp.exceptions import ToolError
 
 
-def get_error_message(status_code: int, url: URL | str, method: str) -> str:
+def get_error_message(
+    status_code: int, url: URL | str, method: str, msg: Optional[str] = None
+) -> str:
     """Get a friendly error message based on the HTTP status code.
 
     Args:
@@ -103,6 +106,7 @@ async def call_get(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling GET '{url}' params: '{params}'")
+    error_message = None
     try:
         response = await client.get(
             url,
@@ -120,7 +124,12 @@ async def call_get(
 
         # Handle different status codes differently
         status_code = response.status_code
-        error_message = get_error_message(status_code, url, "GET")
+        # get the message if available
+        response_data = response.json()
+        if isinstance(response_data, dict) and "detail" in response_data:
+            error_message = response_data["detail"]
+        else:
+            error_message = get_error_message(status_code, url, "PUT")
 
         # Log at appropriate level based on status code
         if 400 <= status_code < 500:
@@ -138,8 +147,6 @@ async def call_get(
         return response  # This line will never execute, but it satisfies the type checker  # pragma: no cover
 
     except HTTPStatusError as e:
-        status_code = e.response.status_code
-        error_message = get_error_message(status_code, url, "GET")
         raise ToolError(error_message) from e
 
 
@@ -183,6 +190,8 @@ async def call_put(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling PUT '{url}'")
+    error_message = None
+
     try:
         response = await client.put(
             url,
@@ -204,7 +213,13 @@ async def call_put(
 
         # Handle different status codes differently
         status_code = response.status_code
-        error_message = get_error_message(status_code, url, "PUT")
+
+        # get the message if available
+        response_data = response.json()
+        if isinstance(response_data, dict) and "detail" in response_data:
+            error_message = response_data["detail"]  # pragma: no cover
+        else:
+            error_message = get_error_message(status_code, url, "PUT")
 
         # Log at appropriate level based on status code
         if 400 <= status_code < 500:
@@ -221,9 +236,110 @@ async def call_put(
         response.raise_for_status()  # Will always raise since we're in the error case
         return response  # This line will never execute, but it satisfies the type checker  # pragma: no cover
 
+    except HTTPStatusError as e:
+        raise ToolError(error_message) from e
+
+
+async def call_patch(
+    client: AsyncClient,
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+    extensions: RequestExtensions | None = None,
+) -> Response:
+    """Make a PATCH request and handle errors appropriately.
+
+    Args:
+        client: The HTTPX AsyncClient to use
+        url: The URL to request
+        content: Request content
+        data: Form data
+        files: Files to upload
+        json: JSON data
+        params: Query parameters
+        headers: HTTP headers
+        cookies: HTTP cookies
+        auth: Authentication
+        follow_redirects: Whether to follow redirects
+        timeout: Request timeout
+        extensions: HTTPX extensions
+
+    Returns:
+        The HTTP response
+
+    Raises:
+        ToolError: If the request fails with an appropriate error message
+    """
+    logger.debug(f"Calling PATCH '{url}'")
+    try:
+        response = await client.patch(
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+        if response.is_success:
+            return response
+
+        # Handle different status codes differently
+        status_code = response.status_code
+
+        # Try to extract specific error message from response body
+        try:
+            response_data = response.json()
+            if isinstance(response_data, dict) and "detail" in response_data:
+                error_message = response_data["detail"]
+            else:
+                error_message = get_error_message(status_code, url, "PATCH")  # pragma: no cover
+        except Exception:  # pragma: no cover
+            error_message = get_error_message(status_code, url, "PATCH")  # pragma: no cover
+
+        # Log at appropriate level based on status code
+        if 400 <= status_code < 500:
+            # Client errors: log as info except for 429 (Too Many Requests)
+            if status_code == 429:  # pragma: no cover
+                logger.warning(f"Rate limit exceeded: PATCH {url}: {error_message}")
+            else:
+                logger.info(f"Client error: PATCH {url}: {error_message}")
+        else:  # pragma: no cover
+            # Server errors: log as error
+            logger.error(f"Server error: PATCH {url}: {error_message}")  # pragma: no cover
+
+        # Raise a tool error with the friendly message
+        response.raise_for_status()  # Will always raise since we're in the error case
+        return response  # This line will never execute, but it satisfies the type checker  # pragma: no cover
+
     except HTTPStatusError as e:
         status_code = e.response.status_code
-        error_message = get_error_message(status_code, url, "PUT")
+
+        # Try to extract specific error message from response body
+        try:
+            response_data = e.response.json()
+            if isinstance(response_data, dict) and "detail" in response_data:
+                error_message = response_data["detail"]
+            else:
+                error_message = get_error_message(status_code, url, "PATCH")  # pragma: no cover
+        except Exception:  # pragma: no cover
+            error_message = get_error_message(status_code, url, "PATCH")  # pragma: no cover
+
         raise ToolError(error_message) from e
 
 
@@ -267,6 +383,7 @@ async def call_post(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling POST '{url}'")
+    error_message = None
     try:
         response = await client.post(
             url=url,
@@ -282,13 +399,19 @@ async def call_post(
             timeout=timeout,
             extensions=extensions,
         )
+        logger.debug(f"response: {response.json()}")
 
         if response.is_success:
             return response
 
         # Handle different status codes differently
         status_code = response.status_code
-        error_message = get_error_message(status_code, url, "POST")
+        # get the message if available
+        response_data = response.json()
+        if isinstance(response_data, dict) and "detail" in response_data:
+            error_message = response_data["detail"]
+        else:
+            error_message = get_error_message(status_code, url, "POST")
 
         # Log at appropriate level based on status code
         if 400 <= status_code < 500:
@@ -306,8 +429,6 @@ async def call_post(
         return response  # This line will never execute, but it satisfies the type checker  # pragma: no cover
 
     except HTTPStatusError as e:
-        status_code = e.response.status_code
-        error_message = get_error_message(status_code, url, "POST")
         raise ToolError(error_message) from e
 
 
@@ -343,6 +464,7 @@ async def call_delete(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling DELETE '{url}'")
+    error_message = None
     try:
         response = await client.delete(
             url=url,
@@ -360,7 +482,12 @@ async def call_delete(
 
         # Handle different status codes differently
         status_code = response.status_code
-        error_message = get_error_message(status_code, url, "DELETE")
+        # get the message if available
+        response_data = response.json()
+        if isinstance(response_data, dict) and "detail" in response_data:
+            error_message = response_data["detail"]  # pragma: no cover
+        else:
+            error_message = get_error_message(status_code, url, "DELETE")
 
         # Log at appropriate level based on status code
         if 400 <= status_code < 500:
@@ -378,6 +505,51 @@ async def call_delete(
         return response  # This line will never execute, but it satisfies the type checker  # pragma: no cover
 
     except HTTPStatusError as e:
-        status_code = e.response.status_code
-        error_message = get_error_message(status_code, url, "DELETE")
         raise ToolError(error_message) from e
+
+
+def check_migration_status() -> Optional[str]:
+    """Check if sync/migration is in progress and return status message if so.
+
+    Returns:
+        Status message if sync is in progress, None if system is ready
+    """
+    try:
+        from basic_memory.services.sync_status_service import sync_status_tracker
+
+        if not sync_status_tracker.is_ready:
+            return sync_status_tracker.get_summary()
+        return None
+    except Exception:
+        # If there's any error checking sync status, assume ready
+        return None
+
+
+async def wait_for_migration_or_return_status(timeout: float = 5.0) -> Optional[str]:
+    """Wait briefly for sync/migration to complete, or return status message.
+
+    Args:
+        timeout: Maximum time to wait for sync completion
+
+    Returns:
+        Status message if sync is still in progress, None if ready
+    """
+    try:
+        from basic_memory.services.sync_status_service import sync_status_tracker
+        import asyncio
+
+        if sync_status_tracker.is_ready:
+            return None
+
+        # Wait briefly for sync to complete
+        start_time = asyncio.get_event_loop().time()
+        while (asyncio.get_event_loop().time() - start_time) < timeout:
+            if sync_status_tracker.is_ready:
+                return None
+            await asyncio.sleep(0.1)  # Check every 100ms
+
+        # Still not ready after timeout
+        return sync_status_tracker.get_summary()
+    except Exception:  # pragma: no cover
+        # If there's any error, assume ready
+        return None

basic_memory/mcp/tools/view_note.py

@@ -0,0 +1,66 @@
+"""View note tool for Basic Memory MCP server."""
+
+from textwrap import dedent
+from typing import Optional
+
+from loguru import logger
+
+from basic_memory.mcp.server import mcp
+from basic_memory.mcp.tools.read_note import read_note
+
+
+@mcp.tool(
+    description="View a note as a formatted artifact for better readability.",
+)
+async def view_note(
+    identifier: str, page: int = 1, page_size: int = 10, project: Optional[str] = None
+) -> str:
+    """View a markdown note as a formatted artifact.
+
+    This tool reads a note using the same logic as read_note but displays the content
+    as a markdown artifact for better viewing experience in Claude Desktop.
+
+    After calling this tool, create an artifact using the returned content to display
+    the note in a readable format. The tool returns the note content that should be
+    used to create a markdown artifact.
+
+    Args:
+        identifier: The title or permalink of the note to view
+        page: Page number for paginated results (default: 1)
+        page_size: Number of items per page (default: 10)
+        project: Optional project name to read from. If not provided, uses current active project.
+
+    Returns:
+        The note content as a markdown artifact with a confirmation message.
+    """
+
+    logger.info(f"Viewing note: {identifier}")
+
+    # Call the existing read_note logic
+    content = await read_note.fn(identifier, page, page_size, project)
+
+    # Check if this is an error message (note not found)
+    if "# Note Not Found:" in content:
+        return content  # Return error message directly instead of creating artifact
+
+    # Extract title from content if possible
+    title = identifier
+    lines = content.split("\n")
+    for line in lines:
+        if line.startswith("title:"):
+            # Extract title from frontmatter
+            title = line.split("title:", 1)[1].strip().strip('"').strip("'")
+            break
+        elif line.startswith("# "):
+            # Extract title from first heading
+            title = line[2:].strip()
+            break
+
+    # Return the artifact XML as part of the response
+    artifact = f'<artifact identifier="note-{hash(identifier) & 0x7FFFFFFF}" type="text/markdown" title="{title}">\n{content}\n</artifact>'
+
+    return dedent(f"""
+            <instructions>
+            Create an artifact using the returned artifact content to display the note in a readable format.
+            </instructions>
+            {artifact}\n\n✅ Note displayed as artifact: **{title}**""")