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

basic_memory/mcp/tools/delete_note.py

@@ -2,15 +2,16 @@ from textwrap import dedent
 from typing import Optional
 
 from loguru import logger
+from fastmcp import Context
 
+from basic_memory.mcp.project_context import get_active_project
 from basic_memory.mcp.tools.utils import call_delete
 from basic_memory.mcp.server import mcp
-from basic_memory.mcp.async_client import client
-from basic_memory.mcp.project_session import get_active_project
+from basic_memory.mcp.async_client import get_client
 from basic_memory.schemas import DeleteEntitiesResponse
 
 
-def _format_delete_error_response(error_message: str, identifier: str) -> str:
+def _format_delete_error_response(project: str, error_message: str, identifier: str) -> str:
     """Format helpful error responses for delete failures that guide users to successful deletions."""
 
     # Note not found errors
@@ -24,7 +25,7 @@ def _format_delete_error_response(error_message: str, identifier: str) -> str:
         return dedent(f"""
             # Delete Failed - Note Not Found
 
-            The note '{identifier}' could not be found for deletion.
+            The note '{identifier}' could not be found for deletion in {project}.
 
             ## This might mean:
             1. **Already deleted**: The note may have been deleted previously
@@ -32,21 +33,21 @@ def _format_delete_error_response(error_message: str, identifier: str) -> str:
             3. **Different project**: The note might be in a different project
 
             ## How to verify:
-            1. **Search for the note**: Use `search_notes("{search_term}")` to find it
+            1. **Search for the note**: Use `search_notes("{project}", "{search_term}")` to find it
             2. **Try different formats**:
                - If you used a permalink like "folder/note-title", try just the title: "{title_format}"
                - If you used a title, try the permalink format: "{permalink_format}"
 
             3. **Check if already deleted**: Use `list_directory("/")` to see what notes exist
-            4. **Check current project**: Use `get_current_project()` to verify you're in the right project
+            4. **List notes in project**: Use `list_directory("/")` to see what notes exist in the current project
 
             ## If the note actually exists:
             ```
             # First, find the correct identifier:
-            search_notes("{identifier}")
+            search_notes("{project}", "{identifier}")
 
             # Then delete using the correct identifier:
-            delete_note("correct-identifier-from-search")
+            delete_note("{project}", "correct-identifier-from-search")
             ```
 
             ## If you want to delete multiple similar notes:
@@ -69,12 +70,12 @@ You don't have permission to delete '{identifier}': {error_message}
 3. **Project access**: Ensure you're in the correct project with proper permissions
 
 ## Alternative actions:
-- Check current project: `get_current_project()`
-- Switch to correct project: `switch_project("project-name")`
-- Verify note exists first: `read_note("{identifier}")`
+- List available projects: `list_memory_projects()`
+- Specify the correct project: `delete_note("{identifier}", project="project-name")`
+- Verify note exists first: `read_note("{identifier}", project="project-name")`
 
 ## If you have read-only access:
-Send a message to support@basicmachines.co to request deletion, or ask someone with write access to delete the note."""
+Ask someone with write access to delete the note."""
 
     # Server/filesystem errors
     if (
@@ -92,8 +93,7 @@ A system error occurred while deleting '{identifier}': {error_message}
 3. **Check disk space**: Ensure the system has adequate storage
 
 ## Troubleshooting:
-- Verify note exists: `read_note("{identifier}")`
-- Check project status: `get_current_project()`
+- Verify note exists: `read_note("{project}","{identifier}")`
 - Try again in a few moments
 
 ## If problem persists:
@@ -112,7 +112,7 @@ A database error occurred while deleting '{identifier}': {error_message}
 
 ## Steps to resolve:
 1. **Try again**: Wait a moment and retry the deletion
-2. **Check note status**: `read_note("{identifier}")` to see current state
+2. **Check note status**: `read_note("{project}","{identifier}")` to see current state
 3. **Manual verification**: Use `list_directory()` to see if file still exists
 
 ## If the note appears gone but database shows it exists:
@@ -124,7 +124,7 @@ Send a message to support@basicmachines.co - a manual database cleanup may be ne
 Error deleting note '{identifier}': {error_message}
 
 ## General troubleshooting:
-1. **Verify the note exists**: `read_note("{identifier}")` or `search_notes("{identifier}")`
+1. **Verify the note exists**: `read_note("{project}", "{identifier}")` or `search_notes("{project}", "{identifier}")`
 2. **Check permissions**: Ensure you can edit/delete files in this project
 3. **Try again**: The error might be temporary
 4. **Check project**: Make sure you're in the correct project
@@ -132,60 +132,94 @@ Error deleting note '{identifier}': {error_message}
 ## Step-by-step approach:
 ```
 # 1. Confirm note exists and get correct identifier
-search_notes("{identifier}")
+search_notes("{project}", "{identifier}")
 
 # 2. Read the note to verify access
-read_note("correct-identifier-from-search")
+read_note("{project}", "correct-identifier-from-search")
 
 # 3. Try deletion with correct identifier
-delete_note("correct-identifier-from-search")
+delete_note("{project}", "correct-identifier-from-search")
 ```
 
 ## Alternative approaches:
-- Check what notes exist: `list_directory("/")`
-- Verify current project: `get_current_project()`
-- Switch projects if needed: `switch_project("correct-project")`
+- Check what notes exist: `list_directory("{project}", "/")`
 
 ## Need help?
-If the note should be deleted but the operation keeps failing, send a message to support@basicmachines.co."""
+If the note should be deleted but the operation keeps failing, send a message to support@basicmemory.com."""
 
 
 @mcp.tool(description="Delete a note by title or permalink")
-async def delete_note(identifier: str, project: Optional[str] = None) -> bool | str:
+async def delete_note(
+    identifier: str, project: Optional[str] = None, context: Context | None = None
+) -> bool | str:
     """Delete a note from the knowledge base.
 
+    Permanently removes a note from the specified project. The note is identified
+    by title or permalink. If the note doesn't exist, the operation returns False
+    without error. If deletion fails due to other issues, helpful error messages are provided.
+
+    Project Resolution:
+    Server resolves projects in this order: Single Project Mode → project parameter → default project.
+    If project unknown, use list_memory_projects() or recent_activity() first.
+
     Args:
-        identifier: Note title or permalink
-        project: Optional project name to delete from. If not provided, uses current active project.
+        project: Project name to delete from. Optional - server will resolve using hierarchy.
+                If unknown, use list_memory_projects() to discover available projects.
+        identifier: Note title or permalink to delete
+                   Can be a title like "Meeting Notes" or permalink like "notes/meeting-notes"
+        context: Optional FastMCP context for performance caching.
 
     Returns:
-        True if note was deleted, False otherwise
+        True if note was successfully deleted, False if note was not found.
+        On errors, returns a formatted string with helpful troubleshooting guidance.
 
     Examples:
         # Delete by title
-        delete_note("Meeting Notes: Project Planning")
+        delete_note("my-project", "Meeting Notes: Project Planning")
 
         # Delete by permalink
-        delete_note("notes/project-planning")
-
-        # Delete from specific project
-        delete_note("notes/project-planning", project="work-project")
-    """
-    active_project = get_active_project(project)
-    project_url = active_project.project_url
+        delete_note("work-docs", "notes/project-planning")
 
-    try:
-        response = await call_delete(client, f"{project_url}/knowledge/entities/{identifier}")
-        result = DeleteEntitiesResponse.model_validate(response.json())
+        # Delete with exact path
+        delete_note("research", "experiments/ml-model-results")
 
-        if result.deleted:
-            logger.info(f"Successfully deleted note: {identifier}")
-            return True
+        # Common usage pattern
+        if delete_note("my-project", "old-draft"):
+            print("Note deleted successfully")
         else:
-            logger.warning(f"Delete operation completed but note was not deleted: {identifier}")
-            return False
+            print("Note not found or already deleted")
 
-    except Exception as e:  # pragma: no cover
-        logger.error(f"Delete failed for '{identifier}': {e}")
-        # Return formatted error message for better user experience
-        return _format_delete_error_response(str(e), identifier)
+    Raises:
+        HTTPError: If project doesn't exist or is inaccessible
+        SecurityError: If identifier attempts path traversal
+
+    Warning:
+        This operation is permanent and cannot be undone. The note file
+        will be removed from the filesystem and all references will be lost.
+
+    Note:
+        If the note is not found, this function provides helpful error messages
+        with suggestions for finding the correct identifier, including search
+        commands and alternative formats to try.
+    """
+    async with get_client() as client:
+        active_project = await get_active_project(client, project, context)
+        project_url = active_project.project_url
+
+        try:
+            response = await call_delete(client, f"{project_url}/knowledge/entities/{identifier}")
+            result = DeleteEntitiesResponse.model_validate(response.json())
+
+            if result.deleted:
+                logger.info(
+                    f"Successfully deleted note: {identifier} in project: {active_project.name}"
+                )
+                return True
+            else:
+                logger.warning(f"Delete operation completed but note was not deleted: {identifier}")
+                return False
+
+        except Exception as e:  # pragma: no cover
+            logger.error(f"Delete failed for '{identifier}': {e}, project: {active_project.name}")
+            # Return formatted error message for better user experience
+            return _format_delete_error_response(active_project.name, str(e), identifier)