basic-memory 0.14.4__py3-none-any.whl → 0.15.1__py3-none-any.whl

basic_memory/mcp/tools/sync_status.py

@@ -3,10 +3,12 @@
 from typing import Optional
 
 from loguru import logger
+from fastmcp import Context
 
 from basic_memory.config import ConfigManager
+from basic_memory.mcp.async_client import get_client
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.project_session import get_active_project
+from basic_memory.mcp.project_context import get_active_project
 from basic_memory.services.sync_status_service import sync_status_tracker
 
 
@@ -79,7 +81,7 @@ def _get_all_projects_status() -> list[str]:
     - Background processing of knowledge graphs
     """,
 )
-async def sync_status(project: Optional[str] = None) -> str:
+async def sync_status(project: Optional[str] = None, context: Context | None = None) -> str:
     """Get current sync status and system readiness information.
 
     This tool provides detailed information about any ongoing or completed
@@ -93,163 +95,167 @@ async def sync_status(project: Optional[str] = None) -> str:
     """
     logger.info("MCP tool call tool=sync_status")
 
-    status_lines = []
+    async with get_client() as client:
+        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:
+        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(
                 [
-                    "✅ **All sync operations completed**",
+                    "# Basic Memory Sync Status",
                     "",
-                    "- File indexing is complete",
-                    "- Knowledge graphs are up to date",
-                    "- All Basic Memory tools are fully operational",
+                    f"**Current Status**: {summary}",
+                    f"**System Ready**: {'✅ Yes' if is_ready else '🔄 Processing'}",
                     "",
-                    "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:
+            if is_ready:
                 status_lines.extend(
                     [
-                        "🔄 **File synchronization in progress**",
+                        "✅ **All sync operations completed**",
                         "",
-                        "Basic Memory is automatically processing all configured projects and building knowledge graphs.",
-                        "This typically takes 1-3 minutes depending on the amount of content.",
+                        "- File indexing is complete",
+                        "- Knowledge graphs are up to date",
+                        "- All Basic Memory tools are fully operational",
                         "",
-                        "**Currently Processing:**",
+                        "Your knowledge base is ready for use!",
                     ]
                 )
 
-                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}%)"
+                # 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()
 
-                    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:**", ""])
+                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"
+                ]
 
-                for project_status in failed_projects:
-                    status_lines.append(
-                        f"- **{project_status.project_name}**: {project_status.error or 'Unknown error'}"
+                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:**",
+                        ]
                     )
 
-                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.",
-                    ]
-                )
+                    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",
+                            "- Settings 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",
+                        ]
+                    )
 
-        # 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)
+                # 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 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 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.",
+                        ]
+                    )
 
-        # 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}")
+            # Add project context if provided
+            if project:
+                try:
+                    active_project = await get_active_project(client, project, context)
+                    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)
+            return "\n".join(status_lines)
 
-    except Exception as e:
-        return f"""# Sync Status - Error
+        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  
+- 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

@@ -107,6 +107,7 @@ async def call_get(
     """
     logger.debug(f"Calling GET '{url}' params: '{params}'")
     error_message = None
+
     try:
         response = await client.get(
             url,
@@ -280,6 +281,7 @@ async def call_patch(
         ToolError: If the request fails with an appropriate error message
     """
     logger.debug(f"Calling PATCH '{url}'")
+
     try:
         response = await client.patch(
             url,
@@ -384,6 +386,7 @@ async def call_post(
     """
     logger.debug(f"Calling POST '{url}'")
     error_message = None
+
     try:
         response = await client.post(
             url=url,
@@ -465,6 +468,7 @@ async def call_delete(
     """
     logger.debug(f"Calling DELETE '{url}'")
     error_message = None
+
     try:
         response = await client.delete(
             url=url,

basic_memory/mcp/tools/view_note.py

@@ -4,6 +4,7 @@ from textwrap import dedent
 from typing import Optional
 
 from loguru import logger
+from fastmcp import Context
 
 from basic_memory.mcp.server import mcp
 from basic_memory.mcp.tools.read_note import read_note
@@ -13,54 +14,64 @@ from basic_memory.mcp.tools.read_note import read_note
     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
+    identifier: str,
+    project: Optional[str] = None,
+    page: int = 1,
+    page_size: int = 10,
+    context: Context | None = 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.
+    This tool reads a note using the same logic as read_note but instructs Claude
+    to display the content as a markdown artifact in the Claude Desktop app.
+    Project parameter optional with server resolution.
 
     Args:
         identifier: The title or permalink of the note to view
+        project: Project name to read from. Optional - server will resolve using hierarchy.
+                If unknown, use list_memory_projects() to discover available projects.
         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.
+        context: Optional FastMCP context for performance caching.
 
     Returns:
-        The note content as a markdown artifact with a confirmation message.
+        Instructions for Claude to create a markdown artifact with the note content.
+
+    Examples:
+        # View a note by title
+        view_note("Meeting Notes")
+
+        # View a note by permalink
+        view_note("meetings/weekly-standup")
+
+        # View with pagination
+        view_note("large-document", page=2, page_size=5)
+
+        # Explicit project specification
+        view_note("Meeting Notes", project="my-project")
+
+    Raises:
+        HTTPError: If project doesn't exist or is inaccessible
+        SecurityError: If identifier attempts path traversal
     """
 
-    logger.info(f"Viewing note: {identifier}")
+    logger.info(f"Viewing note: {identifier} in project: {project}")
 
     # Call the existing read_note logic
-    content = await read_note.fn(identifier, page, page_size, project)
+    content = await read_note.fn(identifier, project, page, page_size, context)
 
     # 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>'
+    if "# Note Not Found" in content:
+        return content  # Return error message directly
 
+    # Return instructions for Claude to create an 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}**""")
+        Note retrieved: "{identifier}"
+        
+        Display this note as a markdown artifact for the user.
+    
+        Content:
+        ---
+        {content}
+        ---
+        """).strip()