feat(mcp): route project-qualified paths in the POSIX tools

src/basic_memory/cli/commands/posix.py

@@ -46,6 +46,7 @@
     _validate_output_flags,
     console,
 )
+
 from basic_memory.schemas.directory import DEFAULT_DIRECTORY_PAGE_SIZE
 
 # MCP tool functions are imported inside each command: importing
@@ -358,10 +359,16 @@ def _add_tree_branches(branch: Tree, entries: dict[str, _TreeEntry]) -> None:
         _add_tree_branches(child, entry.children)
 
 
-def _display_tree(result: dict[str, Any], path: str) -> None:
-    """Render find results as a Rich tree rooted at the search path."""
-    entries = _build_tree(list(result.get("nodes", [])), path)
-    tree = Tree(f"[bold cyan]{markup_escape(path)}[/bold cyan]")
+def _display_tree(result: dict[str, Any], label: str, root: str) -> None:
+    """Render find results as a Rich tree rooted at the search path.
+
+    ``label`` is the caller's spelling of the root; ``root`` is the routed
+    project-relative path the node paths actually start with — a qualified
+    '<project>/dir' input strips its project prefix in the shared tool layer,
+    so the two differ exactly when the input carried a project prefix (#1415).
+    """
+    entries = _build_tree(list(result.get("nodes", [])), root)
+    tree = Tree(f"[bold cyan]{markup_escape(label)}[/bold cyan]")
     if not entries:
         tree.add("[dim]empty[/dim]")
     _add_tree_branches(tree, entries)
@@ -379,10 +386,14 @@ def _print_plain_tree_level(entries: dict[str, _TreeEntry], depth: int) -> None:
         _print_plain_tree_level(entry.children, depth + 1)
 
 
-def _plain_tree(result: dict[str, Any], path: str) -> None:
-    """Render the tree as two-space-indented lines; pagination note on stderr."""
-    print(path)
-    _print_plain_tree_level(_build_tree(list(result.get("nodes", [])), path), depth=1)
+def _plain_tree(result: dict[str, Any], label: str, root: str) -> None:
+    """Render the tree as two-space-indented lines; pagination note on stderr.
+
+    ``label``/``root`` split as in ``_display_tree``: print the caller's
+    spelling, strip the routed project-relative root from node paths.
+    """
+    print(label)
+    _print_plain_tree_level(_build_tree(list(result.get("nodes", [])), root), depth=1)
     if result.get("has_more") is True:
         print(f"… more entries (page {result.get('page', 1)}; use --page)", file=sys.stderr)
 
@@ -811,16 +822,20 @@ def tree(
     # tree is a client-side recombination of find: the same flat listing, with
     # the hierarchy rebuilt from directory paths for display, so its JSON
     # contract is exactly find's payload.
-    from basic_memory.mcp.tools import find as mcp_find
+    from basic_memory.mcp.tools.posix_tools import find_listing
     from fastmcp.exceptions import ToolError
 
     try:
         validate_routing_flags(local, cloud)
         _validate_output_flags(json_output, plain)
 
+        # find returns the listing and the root its node paths are relative to
+        # from one resolution. Resolving here as well cost a second project-list
+        # round trip on every cloud call, because a CLI invocation has no
+        # FastMCP context for the per-request cache to live in (#1421).
         with force_routing(local=local, cloud=cloud):
-            result = run_with_cleanup(
-                mcp_find(
+            result, root = run_with_cleanup(
+                find_listing(
                     path,
                     name=name,
                     depth=depth,
@@ -834,9 +849,9 @@ def tree(
         if mode == "json":
             _print_json(result)
         elif mode == "plain":
-            _plain_tree(result, path)
+            _plain_tree(result, path, root)
         else:
-            _display_tree(result, path)
+            _display_tree(result, path, root)
     except (ValueError, ToolError) as e:
         typer.echo(f"Error: {e}", err=True)
         raise typer.Exit(1)