nmem-cli 0.7.0__tar.gz → 0.7.6__tar.gz

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.7.0
+Version: 0.7.6
 Summary: CLI and TUI for Nowledge Mem - AI memory management
 Project-URL: Homepage, https://mem.nowledge.co/
 Project-URL: Repository, https://github.com/nowledge-co/

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nmem-cli"
-version = "0.7.0"
+version = "0.7.6"
 description = "CLI and TUI for Nowledge Mem - AI memory management"
 authors = [
     {name = "Nowledge Labs"}

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/src/nmem_cli/__init__.py

@@ -20,7 +20,7 @@ Environment (overrides config file):
     NMEM_API_KEY         Optional API key (Bearer auth)
 """
 
-__version__ = "0.7.0"
+__version__ = "0.7.6"
 __author__ = "Nowledge Labs"
 
 from .cli import main

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/src/nmem_cli/cli.py

@@ -13,6 +13,7 @@ import ipaddress
 import json as json_module
 import os
 import platform
+import re
 import shlex
 import shutil
 import subprocess
@@ -1369,6 +1370,47 @@ def _status_version_warning(
     )
 
 
+def _summarize_search_index_status(model_status: dict[str, Any]) -> dict[str, Any]:
+    """Normalize search-index action state for CLI and headless users."""
+    metadata_update_needed = bool(
+        model_status.get("index_metadata_update_needed")
+        or model_status.get("projection_repair_needed")
+    )
+    metadata_update_reason = str(
+        model_status.get("index_metadata_update_reason")
+        or model_status.get("projection_repair_reason")
+        or ""
+    )
+    reindex_needed = bool(model_status.get("reindex_needed"))
+    reindex_reason = str(model_status.get("reindex_reason") or "")
+    available = bool(model_status.get("available_for_indexing"))
+
+    if reindex_needed:
+        return {
+            "status": "rebuild_needed",
+            "action_required": True,
+            "message": reindex_reason or "Search index must be rebuilt.",
+        }
+    if metadata_update_needed:
+        return {
+            "status": "updating_metadata",
+            "action_required": False,
+            "message": metadata_update_reason
+            or "Search metadata is being updated in the background.",
+        }
+    if available:
+        return {
+            "status": "ready",
+            "action_required": False,
+            "message": "Search index is ready.",
+        }
+    return {
+        "status": "model_missing",
+        "action_required": False,
+        "message": str(model_status.get("message") or "Search model is not available."),
+    }
+
+
 def cmd_status() -> None:
     if not is_json_mode():
         with Progress(
@@ -1402,6 +1444,12 @@ def cmd_status() -> None:
     except Exception:
         pass
 
+    search_index: dict[str, Any] | None = None
+    try:
+        search_index = _summarize_search_index_status(api_get("/models/bge-m3/status"))
+    except Exception:
+        search_index = None
+
     if is_json_mode():
         if agent_data:
             result["agent"] = {
@@ -1415,6 +1463,8 @@ def cmd_status() -> None:
                 "usage_unreported_this_hour": agent_data.get("usage_unreported_this_hour", 0),
                 "usage_unreported_today": agent_data.get("usage_unreported_today", 0),
             }
+        if search_index:
+            result["search_index"] = search_index
         output_json(result)
     else:
         status_color = "green" if result["status"] == "ok" else "yellow"
@@ -1435,6 +1485,19 @@ def cmd_status() -> None:
         console.print(
             f"  database {'connected' if result['database'] else 'disconnected'}"
         )
+        if search_index:
+            search_state = search_index["status"]
+            if search_state == "rebuild_needed":
+                state_label = "[yellow]rebuild needed[/yellow]"
+            elif search_state == "updating_metadata":
+                state_label = "[cyan]updating metadata[/cyan]"
+            elif search_state == "ready":
+                state_label = "[green]ready[/green]"
+            else:
+                state_label = "[dim]model missing[/dim]"
+            console.print(f"  search   {state_label}")
+            if search_index.get("message"):
+                console.print(f"           [dim]{search_index['message']}[/dim]")
         version_warning = _status_version_warning(
             cli_version=result["cli_version"],
             server_version=result["server_version"],
@@ -2993,20 +3056,224 @@ def cmd_memories_update(
         console.print(f"  [dim]fields: {', '.join(payload.keys())}[/dim]")
 
 
-def cmd_memories_delete(
-    memory_ids: list[str],
-    force: bool = False,
-    dry_run: bool = False,
-    space_id: str | None = None,
-) -> None:
+def _normalize_cli_ids(raw_ids: list[str] | None) -> list[str]:
     normalized_ids: list[str] = []
     seen: set[str] = set()
-    for memory_id in memory_ids:
-        clean_id = memory_id.strip()
+    for raw_id in raw_ids or []:
+        clean_id = str(raw_id).strip()
         if not clean_id or clean_id in seen:
             continue
         normalized_ids.append(clean_id)
         seen.add(clean_id)
+    return normalized_ids
+
+
+def _selection_source_space(
+    source_space_id: str | None,
+    all_in_space: str | None,
+) -> str | None:
+    if source_space_id and all_in_space and source_space_id != all_in_space:
+        if is_json_mode():
+            output_json(
+                {
+                    "error": "conflicting_space",
+                    "message": (
+                        "--space and --all-in-space refer to different source spaces."
+                    ),
+                }
+            )
+        else:
+            print_error(
+                "Conflicting Spaces",
+                "--space and --all-in-space must match when both are provided.",
+                "Use --space as the source guard for explicit IDs, or "
+                "--all-in-space for whole-space moves.",
+            )
+        return _PREVIEW_ERROR
+    return all_in_space or source_space_id
+
+
+def _memory_move_selection_payload(
+    memory_ids: list[str],
+    *,
+    source_space_id: str | None,
+    all_in_space: str | None,
+    exclude_memory_ids: list[str] | None,
+) -> dict[str, Any] | None:
+    normalized_ids = _normalize_cli_ids(memory_ids)
+    source_space = _selection_source_space(source_space_id, all_in_space)
+    if source_space == _PREVIEW_ERROR:
+        return None
+
+    if all_in_space and normalized_ids:
+        if is_json_mode():
+            output_json(
+                {
+                    "error": "conflicting_selection",
+                    "message": "Pass memory IDs or --all-in-space, not both.",
+                }
+            )
+        else:
+            print_error(
+                "Conflicting Selection",
+                "Pass memory IDs or --all-in-space, not both.",
+            )
+        return None
+
+    if all_in_space:
+        return {
+            "mode": "space",
+            "source_space_id": source_space,
+            "exclude_memory_ids": _normalize_cli_ids(exclude_memory_ids),
+        }
+
+    if not normalized_ids:
+        if is_json_mode():
+            output_json(
+                {
+                    "error": "invalid_input",
+                    "message": "Provide memory IDs or --all-in-space.",
+                }
+            )
+        else:
+            print_error(
+                "Invalid Input",
+                "Provide memory IDs or --all-in-space.",
+                "Example: nmem m move mem-1 mem-2 "
+                "--space Research --to-space Archive",
+            )
+        return None
+
+    payload: dict[str, Any] = {
+        "mode": "ids",
+        "memory_ids": normalized_ids,
+    }
+    if source_space:
+        payload["source_space_id"] = source_space
+    return payload
+
+
+def _display_space_name(
+    preview_or_result: dict[str, Any],
+    key: str,
+    fallback: str | None = None,
+) -> str:
+    fallback_name = str(fallback or "").strip()
+    if fallback_name:
+        return fallback_name
+    value = str(preview_or_result.get(key) or "").strip()
+    return value or "Default"
+
+
+def cmd_memories_move(
+    memory_ids: list[str],
+    *,
+    target_space_id: str,
+    source_space_id: str | None = None,
+    all_in_space: str | None = None,
+    exclude_memory_ids: list[str] | None = None,
+    force: bool = False,
+    dry_run: bool = False,
+) -> None:
+    """Move explicit memories, or every memory in one source space, to another."""
+    target_space = str(target_space_id or "").strip()
+    if not target_space:
+        if is_json_mode():
+            output_json(
+                {"error": "missing_target_space", "message": "Pass --to-space."}
+            )
+        else:
+            print_error("Missing Target Space", "Pass --to-space <space name>.")
+        return
+
+    selection = _memory_move_selection_payload(
+        memory_ids,
+        source_space_id=source_space_id,
+        all_in_space=all_in_space,
+        exclude_memory_ids=exclude_memory_ids,
+    )
+    if selection is None:
+        return
+
+    request = {"selection": selection, "target_space_id": target_space}
+    preview = api_post("/memories/bulk/move/preview", request)
+    display_source_space = _display_space_name(
+        preview,
+        "source_space_id",
+        selection.get("source_space_id"),
+    )
+    display_target_space = _display_space_name(
+        preview,
+        "target_space_id",
+        target_space,
+    )
+    if dry_run:
+        if is_json_mode():
+            output_json({"dry_run": True, **preview})
+        else:
+            console.print("[bold]Dry run[/bold] — no changes will be made.")
+            console.print(
+                f"  [cyan]{preview.get('count', 0)}[/cyan] memories would move "
+                f"from [cyan]{display_source_space}[/cyan] "
+                f"to [cyan]{display_target_space}[/cyan]."
+            )
+            if preview.get("limit_exceeded"):
+                console.print(f"  [yellow]{preview.get('message')}[/yellow]")
+        return
+
+    if not force and not is_json_mode():
+        count = int(preview.get("count", 0) or 0)
+        if preview.get("limit_exceeded"):
+            print_error(
+                "Selection Too Large",
+                str(preview.get("message") or "Too many memories."),
+            )
+            return
+        prompt = (
+            f"Move {count} {'memory' if count == 1 else 'memories'} "
+            f"from {display_source_space} to {display_target_space}?"
+        )
+        if not Confirm.ask(prompt):
+            console.print("[dim]Cancelled[/dim]")
+            return
+
+    if not is_json_mode():
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[cyan]Moving memories...[/cyan]"),
+            console=console,
+            transient=True,
+        ) as p:
+            p.add_task("", total=None)
+            result = api_post("/memories/bulk/move", request)
+    else:
+        result = api_post("/memories/bulk/move", request)
+
+    if is_json_mode():
+        output_json(result)
+        return
+
+    moved = int(result.get("moved_count", 0) or 0)
+    failed = int(result.get("failed_count", 0) or 0)
+    if failed:
+        print_error(
+            "Move completed with failures",
+            f"Moved {moved}, failed {failed}.",
+        )
+    else:
+        print_success(
+            "Moved memories",
+            f"{moved} to {display_target_space}",
+        )
+
+
+def cmd_memories_delete(
+    memory_ids: list[str],
+    force: bool = False,
+    dry_run: bool = False,
+    space_id: str | None = None,
+) -> None:
+    normalized_ids = _normalize_cli_ids(memory_ids)
 
     if not normalized_ids:
         if is_json_mode():
@@ -3953,6 +4220,183 @@ def cmd_threads_delete(
             console.print(f"  [dim]{', '.join(details)}[/dim]")
 
 
+def _thread_move_selection_payload(
+    thread_ids: list[str],
+    *,
+    source_space_id: str | None,
+    all_in_space: str | None,
+    exclude_thread_ids: list[str] | None,
+) -> dict[str, Any] | None:
+    normalized_ids = _normalize_cli_ids(thread_ids)
+    source_space = _selection_source_space(source_space_id, all_in_space)
+    if source_space == _PREVIEW_ERROR:
+        return None
+
+    if all_in_space and normalized_ids:
+        if is_json_mode():
+            output_json(
+                {
+                    "error": "conflicting_selection",
+                    "message": "Pass thread IDs or --all-in-space, not both.",
+                }
+            )
+        else:
+            print_error(
+                "Conflicting Selection",
+                "Pass thread IDs or --all-in-space, not both.",
+            )
+        return None
+
+    if all_in_space:
+        return {
+            "mode": "space",
+            "source_space_id": source_space,
+            "exclude_thread_ids": _normalize_cli_ids(exclude_thread_ids),
+        }
+
+    if not normalized_ids:
+        if is_json_mode():
+            output_json(
+                {
+                    "error": "invalid_input",
+                    "message": "Provide thread IDs or --all-in-space.",
+                }
+            )
+        else:
+            print_error(
+                "Invalid Input",
+                "Provide thread IDs or --all-in-space.",
+                "Example: nmem t move thread-1 thread-2 "
+                "--space Research --to-space Archive",
+            )
+        return None
+
+    payload: dict[str, Any] = {
+        "mode": "ids",
+        "thread_ids": normalized_ids,
+    }
+    if source_space:
+        payload["source_space_id"] = source_space
+    return payload
+
+
+def cmd_threads_move(
+    thread_ids: list[str],
+    *,
+    target_space_id: str,
+    source_space_id: str | None = None,
+    all_in_space: str | None = None,
+    exclude_thread_ids: list[str] | None = None,
+    force: bool = False,
+    dry_run: bool = False,
+) -> None:
+    """Move explicit threads, or every thread in one source space, to another."""
+    target_space = str(target_space_id or "").strip()
+    if not target_space:
+        if is_json_mode():
+            output_json(
+                {"error": "missing_target_space", "message": "Pass --to-space."}
+            )
+        else:
+            print_error("Missing Target Space", "Pass --to-space <space name>.")
+        return
+
+    selection = _thread_move_selection_payload(
+        thread_ids,
+        source_space_id=source_space_id,
+        all_in_space=all_in_space,
+        exclude_thread_ids=exclude_thread_ids,
+    )
+    if selection is None:
+        return
+
+    request = {"selection": selection, "target_space_id": target_space}
+    preview = api_post("/threads/bulk/move/preview", request)
+    display_source_space = _display_space_name(
+        preview,
+        "source_space_id",
+        selection.get("source_space_id"),
+    )
+    display_target_space = _display_space_name(
+        preview,
+        "target_space_id",
+        target_space,
+    )
+    if dry_run:
+        if is_json_mode():
+            output_json({"dry_run": True, **preview})
+        else:
+            console.print("[bold]Dry run[/bold] — no changes will be made.")
+            console.print(
+                f"  [cyan]{preview.get('count', 0)}[/cyan] threads would move "
+                f"from [cyan]{display_source_space}[/cyan] "
+                f"to [cyan]{display_target_space}[/cyan]."
+            )
+            conflicts = preview.get("conflicts") or []
+            if conflicts:
+                console.print(
+                    f"  [yellow]{len(conflicts)} ambiguous legacy threads "
+                    "need review.[/yellow]"
+                )
+            if preview.get("limit_exceeded"):
+                console.print(f"  [yellow]{preview.get('message')}[/yellow]")
+        return
+
+    if not force and not is_json_mode():
+        count = int(preview.get("count", 0) or 0)
+        conflicts = preview.get("conflicts") or []
+        if preview.get("limit_exceeded"):
+            print_error(
+                "Selection Too Large",
+                str(preview.get("message") or "Too many threads."),
+            )
+            return
+        if conflicts:
+            print_error(
+                "Review Required",
+                f"{len(conflicts)} threads are ambiguous legacy records "
+                "and cannot be moved safely.",
+            )
+            return
+        prompt = (
+            f"Move {count} {'thread' if count == 1 else 'threads'} "
+            f"from {display_source_space} to {display_target_space}?"
+        )
+        if not Confirm.ask(prompt):
+            console.print("[dim]Cancelled[/dim]")
+            return
+
+    if not is_json_mode():
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[cyan]Moving threads...[/cyan]"),
+            console=console,
+            transient=True,
+        ) as p:
+            p.add_task("", total=None)
+            result = api_post("/threads/bulk/move", request)
+    else:
+        result = api_post("/threads/bulk/move", request)
+
+    if is_json_mode():
+        output_json(result)
+        return
+
+    moved = int(result.get("moved_count", 0) or 0)
+    failed = int(result.get("failed_count", 0) or 0)
+    conflicts = result.get("conflicts") or []
+    if failed or conflicts:
+        print_error(
+            "Move completed with failures",
+            f"Moved {moved}, failed {failed}.",
+        )
+    else:
+        print_success(
+            "Moved threads",
+            f"{moved} to {display_target_space}",
+        )
+
+
 def cmd_threads_append(
     thread_id: str,
     messages_json: str | None = None,
@@ -5901,6 +6345,9 @@ def cmd_service_logs(user: bool, follow: bool, lines: int) -> None:
 
 _UPDATE_CHECK_URL = "https://backbone-mem.nowledge.co/latest"
 _UPDATE_USER_AGENT = f"nmem-cli/{__version__}"
+_APT_TARGETED_UPGRADE_COMMAND = (
+    "sudo apt-get update && sudo apt-get install --only-upgrade nowledge-mem"
+)
 
 
 def _detect_deployment_type() -> str:
@@ -5979,6 +6426,126 @@ def _check_for_update(platform_id: str) -> Optional[dict]:
         return None
 
 
+def _parse_apt_policy_version(output: str, field: str) -> Optional[str]:
+    """Extract Installed/Candidate version from `apt-cache policy` output."""
+    match = re.search(rf"^\s*{re.escape(field)}:\s*(.+)$", output, re.MULTILINE)
+    if not match:
+        return None
+    value = match.group(1).strip()
+    if value in {"", "(none)"}:
+        return None
+    return value
+
+
+def _is_deb_version_newer(current: str, candidate: str) -> bool:
+    """Compare DEB versions using dpkg semantics when available."""
+    try:
+        result = subprocess.run(
+            ["dpkg", "--compare-versions", candidate, "gt", current],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return _compare_versions(current, candidate)
+
+    if result.returncode == 0:
+        return True
+    if result.returncode == 1:
+        return False
+    return _compare_versions(current, candidate)
+
+
+def _get_apt_policy_versions() -> tuple[Optional[str], Optional[str]]:
+    """Return (installed, candidate) versions known to local APT metadata."""
+    try:
+        result = subprocess.run(
+            ["apt-cache", "policy", "nowledge-mem"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None, None
+
+    if result.returncode != 0:
+        return None, None
+
+    return (
+        _parse_apt_policy_version(result.stdout, "Installed"),
+        _parse_apt_policy_version(result.stdout, "Candidate"),
+    )
+
+
+def _get_dpkg_installed_version() -> Optional[str]:
+    """Read installed DEB version from dpkg when available."""
+    try:
+        result = subprocess.run(
+            ["dpkg-query", "-W", "-f", "${Version}", "nowledge-mem"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        return None
+
+    if result.returncode != 0:
+        return None
+
+    version = result.stdout.strip()
+    return version or None
+
+
+def _build_deb_update_result(current_version: str, update_info: Optional[dict]) -> dict:
+    """Merge release-server and local APT state into one honest update result."""
+    release_version = ""
+    release_notes = ""
+    pub_date = ""
+    file_size = None
+    if isinstance(update_info, dict):
+        release_version = str(update_info.get("version", "") or "")
+        release_notes = str(update_info.get("release_notes", "") or "")
+        pub_date = str(update_info.get("pub_date", "") or "")
+        file_size = update_info.get("file_size")
+
+    apt_installed, apt_candidate = _get_apt_policy_versions()
+    installed_version = _get_dpkg_installed_version() or apt_installed or current_version
+    apt_repo_configured = _is_apt_repo_configured()
+    release_newer = bool(release_version and _is_deb_version_newer(installed_version, release_version))
+    if not apt_repo_configured:
+        return {
+            "current_version": installed_version,
+            "available_version": release_version,
+            "update_available": release_newer,
+            "deployment_type": "deb",
+            "release_notes": release_notes,
+            "pub_date": pub_date,
+            "file_size": file_size,
+            "release_version": release_version,
+            "apt_candidate_version": apt_candidate,
+            "apt_metadata_stale": False,
+            "apt_repo_configured": False,
+        }
+
+    installable_update = bool(apt_candidate and _is_deb_version_newer(installed_version, apt_candidate))
+    apt_metadata_stale = release_newer and not installable_update
+    available_version = release_version if apt_metadata_stale else (apt_candidate or release_version)
+
+    return {
+        "current_version": installed_version,
+        "available_version": available_version,
+        "update_available": installable_update,
+        "deployment_type": "deb",
+        "release_notes": release_notes,
+        "pub_date": pub_date,
+        "file_size": file_size,
+        "release_version": release_version,
+        "apt_candidate_version": apt_candidate,
+        "apt_metadata_stale": apt_metadata_stale,
+        "apt_repo_configured": True,
+    }
+
+
 def _is_apt_repo_configured() -> bool:
     """Check if the Nowledge Mem APT source and GPG key are in place."""
     return (
@@ -6037,50 +6604,85 @@ def cmd_update_check() -> None:
         p.add_task("", total=None)
         update_info = _check_for_update(platform_id)
 
-    if update_info is None:
-        if is_json_mode():
-            output_json({"error": "check_failed", "message": "Could not reach update server"})
-        else:
-            print_error("Check Failed", "Could not reach update server.",
-                        "Check your internet connection and try again.")
-        return
-
-    available = update_info.get("version", "")
-    is_newer = _compare_versions(__version__, available)
-
-    result = {
-        "current_version": __version__,
-        "available_version": available,
-        "update_available": is_newer,
-        "deployment_type": deploy_type,
-        "release_notes": update_info.get("release_notes", ""),
-        "pub_date": update_info.get("pub_date", ""),
-        "file_size": update_info.get("file_size"),
-    }
+    if deploy_type == "deb":
+        result = _build_deb_update_result(__version__, update_info)
+    else:
+        if update_info is None:
+            if is_json_mode():
+                output_json({"error": "check_failed", "message": "Could not reach update server"})
+            else:
+                print_error("Check Failed", "Could not reach update server.",
+                            "Check your internet connection and try again.")
+            return
+        available = update_info.get("version", "")
+        is_newer = _compare_versions(__version__, available)
+        result = {
+            "current_version": __version__,
+            "available_version": available,
+            "update_available": is_newer,
+            "deployment_type": deploy_type,
+            "release_notes": update_info.get("release_notes", ""),
+            "pub_date": update_info.get("pub_date", ""),
+            "file_size": update_info.get("file_size"),
+        }
 
     if is_json_mode():
         output_json(result)
         return
 
     console.print()
-    if is_newer:
+    if result["update_available"]:
         console.print(
             f"[bold green]Update available[/bold green]  "
-            f"[dim]{__version__}[/dim] -> [bold cyan]{available}[/bold cyan]"
+            f"[dim]{result['current_version']}[/dim] -> [bold cyan]{result['available_version']}[/bold cyan]"
         )
-        console.print(f"  Deployment: [cyan]{deploy_type}[/cyan]")
-        notes = update_info.get("release_notes", "")
+        console.print(f"  Deployment: [cyan]{result['deployment_type']}[/cyan]")
+        notes = result.get("release_notes", "")
         if notes:
             console.print(f"  Notes: {notes[:200]}")
         console.print()
         if deploy_type == "deb":
-            console.print("  Run [bold]sudo nmem update apply[/bold] or:")
-            console.print("  [dim]sudo apt-get update && sudo apt-get upgrade nowledge-mem[/dim]")
+            if result.get("apt_repo_configured"):
+                console.print("  Run [bold]sudo nmem update apply[/bold] or:")
+                console.print(f"  [dim]{_APT_TARGETED_UPGRADE_COMMAND}[/dim]")
+            else:
+                console.print("  [yellow]APT repository is not configured on this machine.[/yellow]")
+                console.print(
+                    "  [dim]Reinstall the .deb package, or run the repository setup script first:[/dim]"
+                )
+                console.print(
+                    "  [dim]curl -fsSL https://nowledge-co.github.io/community/apt/install.sh | sudo bash[/dim]"
+                )
         else:
             console.print("  Run [bold]nmem update apply[/bold] to download and install.")
+    elif deploy_type == "deb" and result.get("apt_metadata_stale"):
+        release_version = result.get("release_version") or "a newer release"
+        candidate_version = result.get("apt_candidate_version") or result["current_version"]
+        console.print(
+            "[yellow]Release published, but this machine's APT metadata is still stale[/yellow]"
+        )
+        console.print(
+            f"  Release: [bold cyan]{release_version}[/bold cyan]    "
+            f"APT candidate: [cyan]{candidate_version}[/cyan]"
+        )
+        console.print()
+        console.print(f"  Refresh APT first: [bold]{_APT_TARGETED_UPGRADE_COMMAND}[/bold]")
+        console.print(
+            "  [dim]If APT still offers the old version after refresh, the repo has not published"
+            " this release yet.[/dim]"
+        )
+    elif deploy_type == "deb" and update_info is None:
+        console.print(
+            "[yellow]Release server unavailable.[/yellow] Showing the installable version known to local APT."
+        )
+        console.print()
+        console.print(
+            f"[green]ok[/green] You are on the latest version APT currently offers "
+            f"([cyan]{result['current_version']}[/cyan])"
+        )
     else:
         console.print(
-            f"[green]ok[/green] You are on the latest version ([cyan]{__version__}[/cyan])"
+            f"[green]ok[/green] You are on the latest version ([cyan]{result['current_version']}[/cyan])"
         )
     console.print()
 
@@ -6100,7 +6702,7 @@ def cmd_update_apply(yes: bool = False) -> None:
             print_error(
                 "Unknown Deployment",
                 "Cannot determine if installed via DEB or AppImage.",
-                "For DEB:      sudo apt-get update && sudo apt-get upgrade nowledge-mem\n"
+                f"For DEB:      {_APT_TARGETED_UPGRADE_COMMAND}\n"
                 "For AppImage: set the APPIMAGE env var and re-run.",
             )
         return
@@ -6192,6 +6794,39 @@ def _update_deb(yes: bool) -> None:
             print_error("APT Update Failed", result.stderr.strip())
         return
 
+    installed_version_before = _get_dpkg_installed_version() or __version__
+    _, apt_candidate_version = _get_apt_policy_versions()
+    if not (apt_candidate_version and _is_deb_version_newer(installed_version_before, apt_candidate_version)):
+        latest_release = ""
+        update_info = _check_for_update("linux-deb")
+        if isinstance(update_info, dict):
+            latest_release = str(update_info.get("version", "") or "")
+        if is_json_mode():
+            output_json(
+                {
+                    "status": "apt_not_ready",
+                    "installed_version": installed_version_before,
+                    "apt_candidate_version": apt_candidate_version or installed_version_before,
+                    "release_version": latest_release or None,
+                }
+            )
+        else:
+            if latest_release and _is_deb_version_newer(installed_version_before, latest_release):
+                print_error(
+                    "APT Repository Not Ready",
+                    (
+                        f"Release {latest_release} is published, but APT still offers "
+                        f"{apt_candidate_version or installed_version_before}."
+                    ),
+                    "Wait a moment and run the command again. If it still stays on the old "
+                    "version, the APT repo has not published this release yet.",
+                )
+            else:
+                console.print(
+                    f"[green]ok[/green] Already on the latest version ([cyan]{installed_version_before}[/cyan])"
+                )
+        return
+
     # 6. Install upgrade
     try:
         with Progress(
@@ -6484,8 +7119,11 @@ def cmd_models_status(verify: bool = False, force_refresh: bool = False) -> None
         params["force_refresh"] = True
 
     data = api_get("/models/status", params=params or None)
+    search_index_status = api_get("/models/bge-m3/status")
     if is_json_mode():
-        output_json(data)
+        payload = dict(data)
+        payload["search_index"] = _summarize_search_index_status(search_index_status)
+        output_json(payload)
         return
 
     console.print()
@@ -6554,6 +7192,22 @@ def cmd_models_status(verify: bool = False, force_refresh: bool = False) -> None
             console.print("  [yellow]Some models are installed but not runtime-verified.[/yellow]")
             console.print("  Run [bold]nmem models status --verify[/bold] for full validation.")
 
+    search_index = _summarize_search_index_status(search_index_status)
+    console.print()
+    console.print("[bold]Search Index[/bold]")
+    if search_index["status"] == "rebuild_needed":
+        console.print("  [yellow]Action needed:[/yellow] rebuild search index")
+        console.print(f"  {search_index['message']}")
+        console.print("  Run [bold]nmem models reindex[/bold] when convenient.")
+    elif search_index["status"] == "updating_metadata":
+        console.print("  [cyan]Updating metadata[/cyan]")
+        console.print(f"  {search_index['message']}")
+        console.print("  No rebuild or embedding call is needed.")
+    elif search_index["status"] == "ready":
+        console.print("  [green]Ready[/green]")
+    else:
+        console.print("  [dim]Search model not available yet.[/dim]")
+
     console.print()
 
 
@@ -7811,8 +8465,12 @@ EXAMPLES
   nmem m                            List memories (alias)
   nmem m search "query"             Search memories
   nmem m add "content"              Add memory
+  nmem m move mem-1 --space Research --to-space Archive
+                                   Move memories between spaces
   nmem t                            List threads (alias)
   nmem t create -t "Title" -f x.md  Create from file
+  nmem t move thread-1 --space Research --to-space Archive
+                                   Move threads between spaces
   nmem t append <id> -m '[{{"role":"user","content":"..."}}]'  Append messages
   nmem wm                           Read today's Working Memory
   nmem wm --date 2026-02-12         Read archived WM
@@ -8217,6 +8875,44 @@ PRIORITY
         u.add_argument("-c", "--content")
         u.add_argument("-i", "--importance", type=float, help="New importance 0.0-1.0")
 
+        mv = mem_subs.add_parser(
+            "move",
+            help="Move memories to another space",
+            parents=[_space_parent],
+            epilog="""examples:
+  nmem m move mem-abc123 --space Research --to-space Archive
+  nmem m move mem-1 mem-2 --space "Agent A" --to-space "Agent B" --force
+  nmem m move --all-in-space Default --to-space Archive --force
+  nmem m move --all-in-space Research --exclude mem-keep --to-space Archive --dry-run""",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
+        mv.add_argument("id", nargs="*", help="Memory ID(s) to move")
+        mv.add_argument(
+            "--to-space",
+            required=True,
+            dest="target_space_id",
+            help="Target space name",
+        )
+        mv.add_argument(
+            "--all-in-space",
+            dest="all_in_space",
+            help=(
+                "Move every memory in this source space. Requires confirmation "
+                "unless --force is passed."
+            ),
+        )
+        mv.add_argument(
+            "--exclude",
+            dest="exclude_memory_ids",
+            action="append",
+            help="Memory ID to keep when using --all-in-space (repeatable)",
+        )
+        mv.add_argument("-f", "--force", action="store_true")
+        mv.add_argument(
+            "--dry-run", action="store_true",
+            help="Preview the move without making changes",
+        )
+
         d = mem_subs.add_parser(
             "delete",
             help="Delete",
@@ -8418,6 +9114,44 @@ PRIORITY
             help="Preview what would be deleted without making changes",
         )
 
+        mv = thr_subs.add_parser(
+            "move",
+            help="Move threads to another space",
+            parents=[_space_parent],
+            epilog="""examples:
+  nmem t move thread-abc123 --space Research --to-space Archive
+  nmem t move thread-1 thread-2 --space "Agent A" --to-space "Agent B" --force
+  nmem t move --all-in-space Default --to-space Archive --force
+  nmem t move --all-in-space Research --exclude thread-keep --to-space Archive --dry-run""",
+            formatter_class=argparse.RawDescriptionHelpFormatter,
+        )
+        mv.add_argument("id", nargs="*", help="Thread ID(s) to move")
+        mv.add_argument(
+            "--to-space",
+            required=True,
+            dest="target_space_id",
+            help="Target space name",
+        )
+        mv.add_argument(
+            "--all-in-space",
+            dest="all_in_space",
+            help=(
+                "Move every thread in this source space. Requires confirmation "
+                "unless --force is passed."
+            ),
+        )
+        mv.add_argument(
+            "--exclude",
+            dest="exclude_thread_ids",
+            action="append",
+            help="Thread ID to keep when using --all-in-space (repeatable)",
+        )
+        mv.add_argument("-f", "--force", action="store_true")
+        mv.add_argument(
+            "--dry-run", action="store_true",
+            help="Preview the move without making changes",
+        )
+
         # save - Save coding session as thread
         sv = thr_subs.add_parser(
             "save",
@@ -9237,7 +9971,23 @@ def main() -> int:
                 getattr(args, "space", None),
             )
         elif action == "update":
-            cmd_memories_update(args.id, args.title, args.content, args.importance, getattr(args, "space", None))
+            cmd_memories_update(
+                args.id,
+                args.title,
+                args.content,
+                args.importance,
+                getattr(args, "space", None),
+            )
+        elif action == "move":
+            cmd_memories_move(
+                getattr(args, "id", []),
+                target_space_id=args.target_space_id,
+                source_space_id=getattr(args, "space", None),
+                all_in_space=getattr(args, "all_in_space", None),
+                exclude_memory_ids=getattr(args, "exclude_memory_ids", None),
+                force=getattr(args, "force", False),
+                dry_run=getattr(args, "dry_run", False),
+            )
         elif action == "delete":
             cmd_memories_delete(
                 args.id,
@@ -9246,7 +9996,11 @@ def main() -> int:
                 getattr(args, "space", None),
             )
         else:
-            cmd_memories_list(args.limit, getattr(args, "importance", None), getattr(args, "space", None))
+            cmd_memories_list(
+                args.limit,
+                getattr(args, "importance", None),
+                getattr(args, "space", None),
+            )
     elif cmd in ("threads", "t"):
         action = args.action
         if action == "list":
@@ -9303,7 +10057,23 @@ def main() -> int:
                 idempotency_key=getattr(args, "idempotency_key", None),
             )
         elif action == "delete":
-            cmd_threads_delete(args.id, args.force, getattr(args, "cascade", False), getattr(args, "dry_run", False), getattr(args, "space", None))
+            cmd_threads_delete(
+                args.id,
+                args.force,
+                getattr(args, "cascade", False),
+                getattr(args, "dry_run", False),
+                getattr(args, "space", None),
+            )
+        elif action == "move":
+            cmd_threads_move(
+                getattr(args, "id", []),
+                target_space_id=args.target_space_id,
+                source_space_id=getattr(args, "space", None),
+                all_in_space=getattr(args, "all_in_space", None),
+                exclude_thread_ids=getattr(args, "exclude_thread_ids", None),
+                force=getattr(args, "force", False),
+                dry_run=getattr(args, "dry_run", False),
+            )
         elif action == "save":
             cmd_threads_save(
                 client=args.source_app,

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/src/nmem_cli/tui/api_client.py

@@ -37,6 +37,12 @@ class ApiClient:
             or os.environ.get("NMEM_API_URL")
             or str(config.get("apiUrl") or config.get("api_url") or DEFAULT_API_URL)
         ).rstrip("/")
+        self.space_id = (
+            os.environ.get("NMEM_SPACE")
+            or os.environ.get("NMEM_SPACE_ID")
+            or str(config.get("space") or config.get("space_id") or "").strip()
+            or None
+        )
         env_api_key = os.environ.get("NMEM_API_KEY")
         if env_api_key is not None:
             api_key = env_api_key.strip()
@@ -76,6 +82,21 @@ class ApiClient:
             )
         return self._client
 
+    def _with_space_params(
+        self,
+        params: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        scoped = dict(params or {})
+        if self.space_id:
+            scoped["space_id"] = self.space_id
+        return scoped
+
+    def _with_space_payload(self, payload: dict[str, Any]) -> dict[str, Any]:
+        scoped = dict(payload)
+        if self.space_id and "space_id" not in scoped:
+            scoped["space_id"] = self.space_id
+        return scoped
+
     async def close(self) -> None:
         """Close the HTTP client."""
         if self._client and not self._client.is_closed:
@@ -142,7 +163,7 @@ class ApiClient:
         params: dict[str, Any] = {"limit": limit, "offset": offset}
         if importance_min > 0:
             params["importance_min"] = importance_min
-        response = await client.get("/memories", params=params)
+        response = await client.get("/memories", params=self._with_space_params(params))
         response.raise_for_status()
         return response.json()
 
@@ -161,14 +182,20 @@ class ApiClient:
             params["labels"] = labels
         if importance_min > 0:
             params["importance_min"] = importance_min
-        response = await client.get("/memories/search", params=params)
+        response = await client.get(
+            "/memories/search",
+            params=self._with_space_params(params),
+        )
         response.raise_for_status()
         return response.json()
 
     async def get_memory(self, memory_id: str) -> dict[str, Any]:
         """Get a single memory by ID."""
         client = await self._get_client()
-        response = await client.get(f"/memories/{memory_id}")
+        response = await client.get(
+            f"/memories/{memory_id}",
+            params=self._with_space_params(),
+        )
         response.raise_for_status()
         return response.json()
 
@@ -200,14 +227,20 @@ class ApiClient:
             payload["event_end"] = event_end
         if temporal_context:
             payload["temporal_context"] = temporal_context
-        response = await client.post("/memories", json=payload)
+        response = await client.post(
+            "/memories",
+            json=self._with_space_payload(payload),
+        )
         response.raise_for_status()
         return response.json()
 
     async def delete_memory(self, memory_id: str) -> dict[str, Any]:
         """Delete a memory."""
         client = await self._get_client()
-        response = await client.delete(f"/memories/{memory_id}")
+        response = await client.delete(
+            f"/memories/{memory_id}",
+            params=self._with_space_params(),
+        )
         response.raise_for_status()
         return response.json()
 
@@ -227,7 +260,10 @@ class ApiClient:
             payload["content"] = content
         if importance is not None:
             payload["importance"] = importance
-        response = await client.patch(f"/memories/{memory_id}", json=payload)
+        response = await client.patch(
+            f"/memories/{memory_id}",
+            json=self._with_space_payload(payload),
+        )
         response.raise_for_status()
         return response.json()
 
@@ -239,7 +275,7 @@ class ApiClient:
         """List threads with pagination."""
         client = await self._get_client()
         params = {"limit": limit, "offset": offset}
-        response = await client.get("/threads", params=params)
+        response = await client.get("/threads", params=self._with_space_params(params))
         response.raise_for_status()
         return response.json()
 
@@ -247,14 +283,20 @@ class ApiClient:
         """Search threads."""
         client = await self._get_client()
         params = {"query": query, "limit": limit}
-        response = await client.get("/threads/search", params=params)
+        response = await client.get(
+            "/threads/search",
+            params=self._with_space_params(params),
+        )
         response.raise_for_status()
         return response.json()
 
     async def get_thread(self, thread_id: str) -> dict[str, Any]:
         """Get a thread with messages."""
         client = await self._get_client()
-        response = await client.get(f"/threads/{quote(thread_id, safe='')}")
+        response = await client.get(
+            f"/threads/{quote(thread_id, safe='')}",
+            params=self._with_space_params(),
+        )
         response.raise_for_status()
         return response.json()
 
@@ -264,7 +306,10 @@ class ApiClient:
         """Delete a thread."""
         client = await self._get_client()
         params = {"cascade_delete_memories": cascade}
-        response = await client.delete(f"/threads/{quote(thread_id, safe='')}", params=params)
+        response = await client.delete(
+            f"/threads/{quote(thread_id, safe='')}",
+            params=self._with_space_params(params),
+        )
         response.raise_for_status()
         return response.json()
 

{nmem_cli-0.7.0 → nmem_cli-0.7.6}/src/nmem_cli/tui/app.py

@@ -173,6 +173,8 @@ class NowledgeMemApp(App):
     def __init__(self) -> None:
         super().__init__()
         self.api_client = ApiClient()
+        if self.api_client.space_id:
+            self.SUB_TITLE = f"Space: {self.api_client.space_id}"
         self.register_theme(NOWLEDGE_THEME)
         self.theme = "nowledge"