feat: v0.13.0 pre (#122)

Signed-off-by: phernandez <paul@basicmachines.co>
Co-authored-by: Claude <noreply@anthropic.com>

src/basic_memory/api/app.py

@@ -60,15 +60,18 @@ app = FastAPI(
 
 # Include routers
 app.include_router(knowledge.router, prefix="/{project}")
-app.include_router(management.router, prefix="/{project}")
 app.include_router(memory.router, prefix="/{project}")
 app.include_router(resource.router, prefix="/{project}")
 app.include_router(search.router, prefix="/{project}")
-app.include_router(project.router, prefix="/{project}")
+app.include_router(project.project_router, prefix="/{project}")
 app.include_router(directory_router.router, prefix="/{project}")
 app.include_router(prompt_router.router, prefix="/{project}")
 app.include_router(importer_router.router, prefix="/{project}")
 
+# Project resource router works accross projects
+app.include_router(project.project_resource_router)
+app.include_router(management.router)
+
 # Auth routes are handled by FastMCP automatically when auth is enabled
 
 

src/basic_memory/api/routers/directory_router.py

@@ -1,6 +1,8 @@
 """Router for directory tree operations."""
 
-from fastapi import APIRouter
+from typing import List, Optional
+
+from fastapi import APIRouter, Query
 
 from basic_memory.deps import DirectoryServiceDep, ProjectIdDep
 from basic_memory.schemas.directory import DirectoryNode
@@ -27,3 +29,35 @@ async def get_directory_tree(
 
     # Return the hierarchical tree
     return tree
+
+
+@router.get("/list", response_model=List[DirectoryNode])
+async def list_directory(
+    directory_service: DirectoryServiceDep,
+    project_id: ProjectIdDep,
+    dir_name: str = Query("/", description="Directory path to list"),
+    depth: int = Query(1, ge=1, le=10, description="Recursion depth (1-10)"),
+    file_name_glob: Optional[str] = Query(
+        None, description="Glob pattern for filtering file names"
+    ),
+):
+    """List directory contents with filtering and depth control.
+
+    Args:
+        directory_service: Service for directory operations
+        project_id: ID of the current project
+        dir_name: Directory path to list (default: root "/")
+        depth: Recursion depth (1-10, default: 1 for immediate children only)
+        file_name_glob: Optional glob pattern for filtering file names (e.g., "*.md", "*meeting*")
+
+    Returns:
+        List of DirectoryNode objects matching the criteria
+    """
+    # Get directory listing with filtering
+    nodes = await directory_service.list_directory(
+        dir_name=dir_name,
+        depth=depth,
+        file_name_glob=file_name_glob,
+    )
+
+    return nodes

src/basic_memory/api/routers/knowledge_router.py

@@ -10,6 +10,10 @@ from basic_memory.deps import (
     get_search_service,
     SearchServiceDep,
     LinkResolverDep,
+    ProjectPathDep,
+    FileServiceDep,
+    ProjectConfigDep,
+    AppConfigDep,
 )
 from basic_memory.schemas import (
     EntityListResponse,
@@ -17,6 +21,7 @@ from basic_memory.schemas import (
     DeleteEntitiesResponse,
     DeleteEntitiesRequest,
 )
+from basic_memory.schemas.request import EditEntityRequest, MoveEntityRequest
 from basic_memory.schemas.base import Permalink, Entity
 
 router = APIRouter(prefix="/knowledge", tags=["knowledge"])
@@ -43,41 +48,31 @@ async def create_entity(
     result = EntityResponse.model_validate(entity)
 
     logger.info(
-        "API response",
-        endpoint="create_entity",
-        title=result.title,
-        permalink=result.permalink,
-        status_code=201,
+        f"API response: endpoint='create_entity' title={result.title}, permalink={result.permalink}, status_code=201"
     )
     return result
 
 
 @router.put("/entities/{permalink:path}", response_model=EntityResponse)
 async def create_or_update_entity(
+    project: ProjectPathDep,
     permalink: Permalink,
     data: Entity,
     response: Response,
     background_tasks: BackgroundTasks,
     entity_service: EntityServiceDep,
     search_service: SearchServiceDep,
+    file_service: FileServiceDep,
 ) -> EntityResponse:
     """Create or update an entity. If entity exists, it will be updated, otherwise created."""
     logger.info(
-        "API request",
-        endpoint="create_or_update_entity",
-        permalink=permalink,
-        entity_type=data.entity_type,
-        title=data.title,
+        f"API request: create_or_update_entity for {project=}, {permalink=}, {data.entity_type=}, {data.title=}"
     )
 
     # Validate permalink matches
     if data.permalink != permalink:
         logger.warning(
-            "API validation error",
-            endpoint="create_or_update_entity",
-            permalink=permalink,
-            data_permalink=data.permalink,
-            error="Permalink mismatch",
+            f"API validation error: creating/updating entity with permalink mismatch - url={permalink}, data={data.permalink}",
         )
         raise HTTPException(
             status_code=400,
@@ -93,16 +88,107 @@ async def create_or_update_entity(
     result = EntityResponse.model_validate(entity)
 
     logger.info(
-        "API response",
-        endpoint="create_or_update_entity",
-        title=result.title,
-        permalink=result.permalink,
-        created=created,
-        status_code=response.status_code,
+        f"API response: {result.title=}, {result.permalink=}, {created=}, status_code={response.status_code}"
     )
     return result
 
 
+@router.patch("/entities/{identifier:path}", response_model=EntityResponse)
+async def edit_entity(
+    identifier: str,
+    data: EditEntityRequest,
+    background_tasks: BackgroundTasks,
+    entity_service: EntityServiceDep,
+    search_service: SearchServiceDep,
+) -> EntityResponse:
+    """Edit an existing entity using various operations like append, prepend, find_replace, or replace_section.
+
+    This endpoint allows for targeted edits without requiring the full entity content.
+    """
+    logger.info(
+        f"API request: endpoint='edit_entity', identifier='{identifier}', operation='{data.operation}'"
+    )
+
+    try:
+        # Edit the entity using the service
+        entity = await entity_service.edit_entity(
+            identifier=identifier,
+            operation=data.operation,
+            content=data.content,
+            section=data.section,
+            find_text=data.find_text,
+            expected_replacements=data.expected_replacements,
+        )
+
+        # Reindex the updated entity
+        await search_service.index_entity(entity, background_tasks=background_tasks)
+
+        # Return the updated entity response
+        result = EntityResponse.model_validate(entity)
+
+        logger.info(
+            "API response",
+            endpoint="edit_entity",
+            identifier=identifier,
+            operation=data.operation,
+            permalink=result.permalink,
+            status_code=200,
+        )
+
+        return result
+
+    except Exception as e:
+        logger.error(f"Error editing entity: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/move")
+async def move_entity(
+    data: MoveEntityRequest,
+    background_tasks: BackgroundTasks,
+    entity_service: EntityServiceDep,
+    project_config: ProjectConfigDep,
+    app_config: AppConfigDep,
+    search_service: SearchServiceDep,
+) -> EntityResponse:
+    """Move an entity to a new file location with project consistency.
+
+    This endpoint moves a note to a different path while maintaining project
+    consistency and optionally updating permalinks based on configuration.
+    """
+    logger.info(
+        f"API request: endpoint='move_entity', identifier='{data.identifier}', destination='{data.destination_path}'"
+    )
+
+    try:
+        # Move the entity using the service
+        moved_entity = await entity_service.move_entity(
+            identifier=data.identifier,
+            destination_path=data.destination_path,
+            project_config=project_config,
+            app_config=app_config,
+        )
+
+        # Get the moved entity to reindex it
+        entity = await entity_service.link_resolver.resolve_link(data.destination_path)
+        if entity:
+            await search_service.index_entity(entity, background_tasks=background_tasks)
+
+        logger.info(
+            "API response",
+            endpoint="move_entity",
+            identifier=data.identifier,
+            destination=data.destination_path,
+            status_code=200,
+        )
+        result = EntityResponse.model_validate(moved_entity)
+        return result
+
+    except Exception as e:
+        logger.error(f"Error moving entity: {e}")
+        raise HTTPException(status_code=400, detail=str(e))
+
+
 ## Read endpoints
 
 
@@ -164,8 +250,8 @@ async def delete_entity(
     # Delete the entity
     deleted = await entity_service.delete_entity(entity.permalink or entity.id)
 
-    # Remove from search index
-    background_tasks.add_task(search_service.delete_by_permalink, entity.permalink)
+    # Remove from search index (entity, observations, and relations)
+    background_tasks.add_task(search_service.handle_delete, entity)
 
     result = DeleteEntitiesResponse(deleted=deleted)
     return result
@@ -188,4 +274,4 @@ async def delete_entities(
         background_tasks.add_task(search_service.delete_by_permalink, permalink)
 
     result = DeleteEntitiesResponse(deleted=deleted)
-    return result
+    return result

src/basic_memory/api/routers/project_router.py

@@ -8,17 +8,18 @@ from basic_memory.schemas import ProjectInfoResponse
 from basic_memory.schemas.project_info import (
     ProjectList,
     ProjectItem,
-    ProjectSwitchRequest,
+    ProjectInfoRequest,
     ProjectStatusResponse,
-    ProjectWatchStatus,
 )
 
-# Define the router - we'll combine stats and project operations
-router = APIRouter(prefix="/project", tags=["project"])
+# Router for resources in a specific project
+project_router = APIRouter(prefix="/project", tags=["project"])
+
+# Router for managing project resources
+project_resource_router = APIRouter(prefix="/projects", tags=["project_management"])
 
 
-# Get project information (moved from project_info_router.py)
-@router.get("/info", response_model=ProjectInfoResponse)
+@project_router.get("/info", response_model=ProjectInfoResponse)
 async def get_project_info(
     project_service: ProjectServiceDep,
 ) -> ProjectInfoResponse:
@@ -26,8 +27,49 @@ async def get_project_info(
     return await project_service.get_project_info()
 
 
+# Update a project
+@project_router.patch("/{name}", response_model=ProjectStatusResponse)
+async def update_project(
+    project_service: ProjectServiceDep,
+    project_name: str = Path(..., description="Name of the project to update"),
+    path: Optional[str] = Body(None, description="New path for the project"),
+    is_active: Optional[bool] = Body(None, description="Status of the project (active/inactive)"),
+) -> ProjectStatusResponse:
+    """Update a project's information in configuration and database.
+
+    Args:
+        project_name: The name of the project to update
+        path: Optional new path for the project
+        is_active: Optional status update for the project
+
+    Returns:
+        Response confirming the project was updated
+    """
+    try:  # pragma: no cover
+        # Get original project info for the response
+        old_project = ProjectItem(
+            name=project_name,
+            path=project_service.projects.get(project_name, ""),
+        )
+
+        await project_service.update_project(project_name, updated_path=path, is_active=is_active)
+
+        # Get updated project info
+        updated_path = path if path else project_service.projects.get(project_name, "")
+
+        return ProjectStatusResponse(
+            message=f"Project '{project_name}' updated successfully",
+            status="success",
+            default=(project_name == project_service.default_project),
+            old_project=old_project,
+            new_project=ProjectItem(name=project_name, path=updated_path),
+        )
+    except ValueError as e:  # pragma: no cover
+        raise HTTPException(status_code=400, detail=str(e))
+
+
 # List all available projects
-@router.get("/projects", response_model=ProjectList)
+@project_resource_router.get("/projects", response_model=ProjectList)
 async def list_projects(
     project_service: ProjectServiceDep,
 ) -> ProjectList:
@@ -36,32 +78,28 @@ async def list_projects(
     Returns:
         A list of all projects with metadata
     """
-    projects_dict = project_service.projects
+    projects = await project_service.list_projects()
     default_project = project_service.default_project
-    current_project = project_service.current_project
 
-    project_items = []
-    for name, path in projects_dict.items():
-        project_items.append(
-            ProjectItem(
-                name=name,
-                path=path,
-                is_default=(name == default_project),
-                is_current=(name == current_project),
-            )
+    project_items = [
+        ProjectItem(
+            name=project.name,
+            path=project.path,
+            is_default=project.is_default or False,
         )
+        for project in projects
+    ]
 
     return ProjectList(
         projects=project_items,
         default_project=default_project,
-        current_project=current_project,
     )
 
 
 # Add a new project
-@router.post("/projects", response_model=ProjectStatusResponse)
+@project_resource_router.post("/projects", response_model=ProjectStatusResponse)
 async def add_project(
-    project_data: ProjectSwitchRequest,
+    project_data: ProjectInfoRequest,
     project_service: ProjectServiceDep,
 ) -> ProjectStatusResponse:
     """Add a new project to configuration and database.
@@ -82,10 +120,8 @@ async def add_project(
             message=f"Project '{project_data.name}' added successfully",
             status="success",
             default=project_data.set_default,
-            new_project=ProjectWatchStatus(
-                name=project_data.name,
-                path=project_data.path,
-                watch_status=None,
+            new_project=ProjectItem(
+                name=project_data.name, path=project_data.path, is_default=project_data.set_default
             ),
         )
     except ValueError as e:  # pragma: no cover
@@ -93,7 +129,7 @@ async def add_project(
 
 
 # Remove a project
-@router.delete("/projects/{name}", response_model=ProjectStatusResponse)
+@project_resource_router.delete("/{name}", response_model=ProjectStatusResponse)
 async def remove_project(
     project_service: ProjectServiceDep,
     name: str = Path(..., description="Name of the project to remove"),
@@ -106,28 +142,26 @@ async def remove_project(
     Returns:
         Response confirming the project was removed
     """
-    try:  # pragma: no cover
-        # Get project info before removal for the response
-        old_project = ProjectWatchStatus(
-            name=name,
-            path=project_service.projects.get(name, ""),
-            watch_status=None,
-        )
+    try:
+        old_project = await project_service.get_project(name)
+        if not old_project:  # pragma: no cover
+            raise HTTPException(status_code=404, detail=f"Project: '{name}' does not exist")  # pragma: no cover
 
         await project_service.remove_project(name)
 
-        return ProjectStatusResponse(  # pyright: ignore [reportCallIssue]
+        return ProjectStatusResponse(
             message=f"Project '{name}' removed successfully",
             status="success",
             default=False,
-            old_project=old_project,
+            old_project=ProjectItem(name=old_project.name, path=old_project.path),
+            new_project=None,
         )
     except ValueError as e:  # pragma: no cover
         raise HTTPException(status_code=400, detail=str(e))
 
 
 # Set a project as default
-@router.put("/projects/{name}/default", response_model=ProjectStatusResponse)
+@project_resource_router.put("/{name}/default", response_model=ProjectStatusResponse)
 async def set_default_project(
     project_service: ProjectServiceDep,
     name: str = Path(..., description="Name of the project to set as default"),
@@ -140,78 +174,39 @@ async def set_default_project(
     Returns:
         Response confirming the project was set as default
     """
-    try:  # pragma: no cover
+    try:
         # Get the old default project
-        old_default = project_service.default_project
-        old_project = None
-        if old_default != name:
-            old_project = ProjectWatchStatus(
-                name=old_default,
-                path=project_service.projects.get(old_default, ""),
-                watch_status=None,
+        default_name = project_service.default_project
+        default_project = await project_service.get_project(default_name)
+        if not default_project:  # pragma: no cover
+            raise HTTPException(  # pragma: no cover
+                status_code=404, detail=f"Default Project: '{default_name}' does not exist"
             )
 
+        # get the new project
+        new_default_project = await project_service.get_project(name)
+        if not new_default_project:  # pragma: no cover
+            raise HTTPException(status_code=404, detail=f"Project: '{name}' does not exist")  # pragma: no cover
+
         await project_service.set_default_project(name)
 
         return ProjectStatusResponse(
             message=f"Project '{name}' set as default successfully",
             status="success",
             default=True,
-            old_project=old_project,
-            new_project=ProjectWatchStatus(
+            old_project=ProjectItem(name=default_name, path=default_project.path),
+            new_project=ProjectItem(
                 name=name,
-                path=project_service.projects.get(name, ""),
-                watch_status=None,
+                path=new_default_project.path,
+                is_default=True,
             ),
         )
     except ValueError as e:  # pragma: no cover
         raise HTTPException(status_code=400, detail=str(e))
 
 
-# Update a project
-@router.patch("/projects/{name}", response_model=ProjectStatusResponse)
-async def update_project(
-    project_service: ProjectServiceDep,
-    name: str = Path(..., description="Name of the project to update"),
-    path: Optional[str] = Body(None, description="New path for the project"),
-    is_active: Optional[bool] = Body(None, description="Status of the project (active/inactive)"),
-) -> ProjectStatusResponse:
-    """Update a project's information in configuration and database.
-
-    Args:
-        name: The name of the project to update
-        path: Optional new path for the project
-        is_active: Optional status update for the project
-
-    Returns:
-        Response confirming the project was updated
-    """
-    try:  # pragma: no cover
-        # Get original project info for the response
-        old_project = ProjectWatchStatus(
-            name=name,
-            path=project_service.projects.get(name, ""),
-            watch_status=None,
-        )
-
-        await project_service.update_project(name, updated_path=path, is_active=is_active)
-
-        # Get updated project info
-        updated_path = path if path else project_service.projects.get(name, "")
-
-        return ProjectStatusResponse(
-            message=f"Project '{name}' updated successfully",
-            status="success",
-            default=(name == project_service.default_project),
-            old_project=old_project,
-            new_project=ProjectWatchStatus(name=name, path=updated_path, watch_status=None),
-        )
-    except ValueError as e:  # pragma: no cover
-        raise HTTPException(status_code=400, detail=str(e))
-
-
 # Synchronize projects between config and database
-@router.post("/sync", response_model=ProjectStatusResponse)
+@project_resource_router.post("/sync", response_model=ProjectStatusResponse)
 async def synchronize_projects(
     project_service: ProjectServiceDep,
 ) -> ProjectStatusResponse: