fix(cli): show embedding progress when bm project add indexes

bm project add indexed through one foreground API request that embeds
inline and prints nothing until it returns; a 1000-note project sat silent
for two minutes. The add now runs the same pass as bm project index: the
search pass, then the embedding pass under the existing Rich progress bar
from bm reindex. Embeddings follow semantic_search_enabled without the
warning an explicit reindex prints.

Reindex now matches --project by permalink. Config reconciliation stores
normalized names, so `new_default` missed the `new-default` row it had just
written. The reconciliation also normalizes the config key at add time, as
initialization already does elsewhere; the integration test asserts that.

Part of #1635.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01APFUk2bjEwMptMQqpRhjea
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/cli/commands/command_utils.py

@@ -132,17 +132,6 @@ async def report_project_readiness(project: str) -> None:
     console.print(f"[dim]{escape(project_item.name)}: {summary}[/dim]")
 
 
-async def index_project_and_report_readiness(project: str) -> None:
-    """Index a project, then say what state that left it in.
-
-    One coroutine so the caller opens the database once for both steps:
-    `run_with_cleanup` shuts the engine down on exit, so a second call would pay
-    the reconnect and the migration check over again.
-    """
-    await run_project_index(project, force_full=True, run_in_background=False)
-    await report_project_readiness(project)
-
-
 async def get_project_info(project: str):
     """Get project information via API endpoint."""
     # Deferred: ToolError lives in FastMCP's runtime, which must not load at CLI startup (#886).

src/basic_memory/cli/commands/db.py

@@ -17,8 +17,9 @@
 from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
 
 from basic_memory.cli.app import app
-from basic_memory.cli.commands.command_utils import run_with_cleanup
+from basic_memory.cli.commands.command_utils import report_project_readiness, run_with_cleanup
 from basic_memory.config import ConfigManager, ProjectMode
+from basic_memory.utils import generate_permalink
 
 console = Console()
 REINDEX_ERROR_SUMMARY_MAX_LENGTH = 240
@@ -304,6 +305,33 @@ def run_reindex_command(
     )
 
 
+async def index_project_and_report_readiness(project: str) -> None:
+    """Index a just-added project the way `bm project index` does, then report readiness.
+
+    `bm project add` used to index through the API in one foreground request,
+    which embeds inline and prints nothing until it returns: a 1000-note project
+    sat silent for two minutes between "added successfully" and the final count
+    (#1635). `_reindex` runs the search pass and then the embedding pass under the
+    progress bar `bm reindex` shows, so the add reports progress and leaves the
+    project in the state its own remedy, `bm project index`, would.
+
+    It is incremental (`full=False`) for the same reason the remedy is: change
+    detection sees every file of a never-indexed project as new, and an adopted,
+    already-indexed project only redoes what changed.
+    """
+    app_config = ConfigManager().config
+    # Semantic search off is a supported configuration, not a failure, so the
+    # embedding pass is skipped without the warning an explicit reindex prints.
+    await _reindex(
+        app_config,
+        search=True,
+        embeddings=app_config.semantic_search_enabled,
+        full=False,
+        project=project,
+    )
+    await report_project_readiness(project)
+
+
 @app.command()
 def reindex(
     embeddings: bool = typer.Option(
@@ -377,7 +405,14 @@ async def _reindex(
             projects = await project_repository.get_active_projects(session)
 
         if project:
-            projects = [p for p in projects if p.name == project]
+            # Trigger: the caller names the project as typed, e.g. `new_default`.
+            # Why: config reconciliation above stores normalized names
+            #      (`new-default`), so exact name equality can miss the project
+            #      the caller just registered; the API resolves by permalink too.
+            # Outcome: `bm project add new_default` and `bm project index
+            #          new_default` index the project they name.
+            project_permalink = generate_permalink(project)
+            projects = [p for p in projects if p.permalink == project_permalink]
             if not projects:
                 # Check if it's a cloud-only project — those can't be reindexed locally
                 project_mode = app_config.get_project_mode(project)

src/basic_memory/cli/commands/project.py

@@ -28,10 +28,9 @@
 )
 from basic_memory.cli.commands.command_utils import (
     get_project_info,
-    index_project_and_report_readiness,
     run_with_cleanup,
 )
-from basic_memory.cli.commands.db import run_reindex_command
+from basic_memory.cli.commands.db import index_project_and_report_readiness, run_reindex_command
 from basic_memory.cli.commands.routing import force_routing, validate_routing_flags
 from basic_memory.config import BasicMemoryConfig, ConfigManager, ProjectEntry, ProjectMode
 from basic_memory.mcp.async_client import get_client, resolve_configured_workspace
@@ -820,7 +819,7 @@ def _abort_after_project_created(
     deleting it to tidy up an error message would discard what they asked for.
     """
     # A typer.Exit carries no message of its own -- the failing step already
-    # printed one (run_project_index does) -- so only the state and remedy are
+    # printed one (the reindex pass does) -- so only the state and remedy are
     # missing. Anything else still needs its message shown.
     detail = "" if isinstance(error, typer.Exit) else f": {error}"
     console.print(f"[yellow]Project '{name}' was created, but {step} failed{detail}[/yellow]")

test-int/cli/test_project_commands_integration.py

@@ -170,7 +170,9 @@ def test_remove_main_project(app, app_config, config_manager):
         assert result.exit_code == 0
         config_after_list = config_manager.load_config()
         assert "main" not in config_after_list.projects
-        assert "new_default" in config_after_list.projects
+        # `project add` indexes through the same pass as `bm project index`
+        # (#1635), whose config reconciliation stores the normalized key.
+        assert "new-default" in config_after_list.projects
 
 
 def test_local_project_remove_keeps_files_without_delete_notes(app, app_config, config_manager):

tests/cli/test_command_utils.py

@@ -1,5 +1,13 @@
 """Tests for CLI command utilities."""
 
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+import basic_memory.cli.commands.command_utils as command_utils
 import basic_memory.index.note_content_materialization as note_content_materialization
 import basic_memory.db as db
 import basic_memory.index.local_schedulers as local_schedulers
@@ -38,3 +46,49 @@ async def work() -> int:
 
     assert result == 42
     assert calls == ["work", "drain-materializations", "drain-background", "shutdown"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "response,expected",
+    [
+        ({"message": "Indexing started in background"}, "Indexing started in background"),
+        (
+            {"total_files": 3, "enqueued_files": 2, "enqueued_batches": 1, "deleted_files": 0},
+            "Indexed 2/3 files (batches: 1, deleted orphans: 0)",
+        ),
+    ],
+)
+async def test_run_project_index_reports_background_and_foreground_responses(
+    monkeypatch, response: dict[str, object], expected: str
+):
+    """`bm project add` no longer calls this; cloud project indexing still does."""
+    printed: list[str] = []
+
+    @asynccontextmanager
+    async def fake_get_client(project_name: str | None = None) -> AsyncIterator[object]:
+        yield object()
+
+    class FakeProjectClient:
+        def __init__(self, client: object) -> None:
+            pass
+
+        async def index(self, external_id: str, **kwargs: bool) -> dict[str, object]:
+            assert external_id == "project-ext"
+            return response
+
+    monkeypatch.setattr(command_utils, "get_client", fake_get_client)
+    monkeypatch.setattr(
+        command_utils,
+        "get_active_project",
+        AsyncMock(return_value=SimpleNamespace(external_id="project-ext")),
+    )
+    monkeypatch.setattr(command_utils, "ProjectClient", FakeProjectClient)
+    monkeypatch.setattr(
+        command_utils.console, "print", lambda message="", *a, **k: printed.append(str(message))
+    )
+
+    await command_utils.run_project_index("research")
+
+    [line] = printed
+    assert expected in line.replace("[green]", "").replace("[/green]", "")

tests/cli/test_db_reindex.py

@@ -73,7 +73,7 @@ def _configure_embedding_runtime(
 ) -> tuple[SimpleNamespace, AsyncMock, list[str]]:
     """Install the runtime boundaries needed to exercise the real reindex command."""
     app_config = _stub_app_config()
-    project = SimpleNamespace(id=1, name="foo", path="/tmp/foo")
+    project = SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo")
     printed_lines: list[str] = []
     project_index = AsyncMock(
         return_value=SimpleNamespace(
@@ -282,7 +282,7 @@ async def test_reindex_project_full_uses_core_project_index_and_reports_summary(
     session_maker,
 ):
     app_config = _stub_app_config()
-    project = SimpleNamespace(id=1, name="foo", path="/tmp/foo")
+    project = SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo")
     project_index = AsyncMock(
         return_value=SimpleNamespace(
             total_files=3,
@@ -343,7 +343,7 @@ async def test_reindex_embeddings_only_full_passes_force_full_to_vector_reindex(
     session_maker,
 ):
     app_config = _stub_app_config()
-    project = SimpleNamespace(id=1, name="foo", path="/tmp/foo")
+    project = SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo")
     printed_lines: list[str] = []
     vector_reindex_calls: list[dict[str, object]] = []
 
@@ -443,7 +443,7 @@ async def test_reindex_embeddings_only_warns_when_project_has_no_indexed_entitie
 ):
     """Embeddings-only mode explains that it cannot discover project files."""
     app_config = _stub_app_config()
-    project = SimpleNamespace(id=1, name="foo", path="/tmp/foo")
+    project = SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo")
     printed_lines: list[str] = []
 
     class StubProjectRepository:
@@ -530,8 +530,8 @@ async def test_reindex_recovers_stuck_materializations_before_scan(monkeypatch,
     as a missing file. Recovery must re-drive stuck rows before each project scan."""
     app_config = _stub_app_config()
     projects = [
-        SimpleNamespace(id=1, name="foo", path="/tmp/foo"),
-        SimpleNamespace(id=2, name="bar", path="/tmp/bar"),
+        SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo"),
+        SimpleNamespace(id=2, name="bar", permalink="bar", path="/tmp/bar"),
     ]
     call_order: list[str] = []
 
@@ -721,7 +721,7 @@ async def test_reindex_full_does_not_double_embed(monkeypatch, session_maker):
     """A full reindex (search + embeddings) must embed once: the FTS rebuild runs
     with embeddings=False so only the explicit vector phase calls the provider."""
     app_config = _stub_app_config()
-    project = SimpleNamespace(id=1, name="foo", path="/tmp/foo")
+    project = SimpleNamespace(id=1, name="foo", permalink="foo", path="/tmp/foo")
     vector_reindex_calls: list[dict[str, object]] = []
     project_index = AsyncMock(
         return_value=SimpleNamespace(
@@ -878,3 +878,77 @@ def test_reindex_embedding_success_reports_index_and_model_and_exits_zero(
     ) in output
     assert "Representative error:" not in output
     assert "Reindex complete!" in output
+
+
+# --- `bm project add` indexing (#1635) ---
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("semantic_search_enabled", [True, False])
+async def test_project_add_indexing_runs_the_reindex_pass_then_reports_readiness(
+    monkeypatch, semantic_search_enabled: bool
+):
+    """`project add` reuses the reindex pass, so its embedding phase shows the progress bar.
+
+    The old path made one foreground API request that embedded inline and printed
+    nothing until it returned. Embeddings follow the config here, without the
+    "Semantic search is not enabled" warning an explicit reindex prints.
+    """
+    app_config = _stub_app_config(semantic_search_enabled=semantic_search_enabled)
+    monkeypatch.setattr(db_cmd, "ConfigManager", lambda: SimpleNamespace(config=app_config))
+    steps: list[tuple[str, object]] = []
+
+    async def fake_reindex(config, **kwargs):
+        assert config is app_config
+        steps.append(("reindex", kwargs))
+
+    async def fake_report(project: str) -> None:
+        steps.append(("readiness", project))
+
+    monkeypatch.setattr(db_cmd, "_reindex", fake_reindex)
+    monkeypatch.setattr(db_cmd, "report_project_readiness", fake_report)
+
+    await db_cmd.index_project_and_report_readiness("research")
+
+    assert steps == [
+        (
+            "reindex",
+            {
+                "search": True,
+                "embeddings": semantic_search_enabled,
+                "full": False,
+                "project": "research",
+            },
+        ),
+        ("readiness", "research"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_reindex_matches_the_project_by_permalink(monkeypatch, session_maker):
+    """`new_default` names the project reconciliation stored as `new-default`.
+
+    Exact name equality missed it, so `bm project add new_default` reported its
+    own index pass as "Project 'new_default' not found".
+    """
+    stats = _vector_stats(total_entities=1, embedded=1, skipped=0, errors=0)
+    _, project_index, _ = _configure_embedding_runtime(monkeypatch, session_maker, stats)
+    stored = SimpleNamespace(id=1, name="new-default", permalink="new-default", path="/tmp/n")
+
+    class NormalizedProjectRepository:
+        async def get_active_projects(self, session):
+            return [stored]
+
+    monkeypatch.setattr("basic_memory.repository.ProjectRepository", NormalizedProjectRepository)
+
+    await db_cmd._reindex(
+        _stub_app_config(),
+        search=True,
+        embeddings=False,
+        full=False,
+        project="new_default",
+    )
+
+    project_index.assert_awaited_once()
+    [indexed_call] = project_index.await_args_list
+    assert indexed_call.args[0] is stored

tests/cli/test_project_add_indexing.py

@@ -109,6 +109,9 @@ def test_project_add_indexes_files_already_on_disk(tmp_path):
 
     add = _bm(["project", "add", "adopted", str(notes)], env)
     assert add.returncode == 0, add.stderr
+    # The add runs the same visible pass as `bm project index` rather than one
+    # silent API request (#1635).
+    assert "Rebuilding full-text search index" in add.stdout
 
     # No reindex is run here. That is the entire point of the test.
     search = _bm(["tool", "search-notes", "Alpha Note", "--project", "adopted", "--json"], env)