nmem-cli 0.8.8__tar.gz → 0.9.2__tar.gz

{nmem_cli-0.8.8 → nmem_cli-0.9.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nmem-cli
-Version: 0.8.8
+Version: 0.9.2
 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.8.8 → nmem_cli-0.9.2}/pyproject.toml

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

{nmem_cli-0.8.8 → nmem_cli-0.9.2}/src/nmem_cli/__init__.py

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

nmem_cli-0.9.2/src/nmem_cli/agent_profiles.py

@@ -0,0 +1,298 @@
+"""Agent identity commands for the nmem CLI."""
+
+from __future__ import annotations
+
+import argparse
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any
+from urllib.parse import quote
+
+from rich import box
+from rich.console import Console
+from rich.prompt import Confirm
+from rich.table import Table
+
+
+@dataclass(frozen=True)
+class AgentProfileCommandDeps:
+    api_get: Callable[..., dict[str, Any]]
+    api_post: Callable[..., dict[str, Any]]
+    api_put: Callable[..., dict[str, Any]]
+    api_delete: Callable[..., dict[str, Any]]
+    is_json_mode: Callable[[], bool]
+    output_json: Callable[[Any], None]
+    print_success: Callable[[str, str | None], None]
+    print_error: Callable[[str, str, str | None], None]
+    console: Console
+    confirm: Callable[[str], bool] = Confirm.ask
+
+
+def register_agents_parser(subparsers: argparse._SubParsersAction) -> None:
+    """Register `nmem agents` commands."""
+    parser = subparsers.add_parser(
+        "agents",
+        help="Named agent identities consumed by Context Bundle",
+        epilog="""examples:
+  nmem agents
+  nmem agents show designer
+  nmem agents upsert designer --name "Design Agent" --default-space design
+  nmem agents delete designer --yes
+  nmem --json agents list""",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    agent_subs = parser.add_subparsers(dest="action")
+    agent_subs.add_parser("list", help="List agent identities (default)")
+
+    show = agent_subs.add_parser("show", help="Show one agent identity")
+    show.add_argument("id", help="Agent identity id")
+
+    upsert = agent_subs.add_parser(
+        "upsert",
+        help="Create or update one agent identity",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    upsert.add_argument("id", help="Stable agent identity id")
+    upsert.add_argument("--name", dest="display_name", help="Display name")
+    upsert.add_argument("--role", help="Role, e.g. engineer, designer")
+    upsert.add_argument("--default-space", help="Default memory space id")
+    upsert.add_argument("--source-app", help="Calling app, e.g. codex, hermes")
+    upsert.add_argument("--host-agent-id", help="Host-local agent id, if known")
+    upsert.add_argument("--description", help="Short description of ownership")
+    upsert.add_argument(
+        "--rules",
+        "--instructions",
+        dest="instructions",
+        help="Agent-specific rules",
+    )
+    upsert.add_argument(
+        "--tag",
+        dest="tags",
+        action="append",
+        default=[],
+        help="Tag for this agent identity; can be repeated",
+    )
+    upsert.add_argument(
+        "--tags",
+        dest="tags_csv",
+        help="Comma-separated tags for this agent identity",
+    )
+
+    delete = agent_subs.add_parser("delete", help="Delete one agent identity")
+    delete.add_argument("id", help="Agent identity id")
+    delete.add_argument(
+        "-y",
+        "--yes",
+        "--force",
+        action="store_true",
+        dest="yes",
+        help="Delete without interactive confirmation",
+    )
+
+
+def handle_agents_command(args: argparse.Namespace, deps: AgentProfileCommandDeps) -> int:
+    """Dispatch `nmem agents` commands."""
+    action = getattr(args, "action", None) or "list"
+    if action == "list":
+        return cmd_agents_list(deps)
+    if action == "show":
+        return cmd_agents_show(getattr(args, "id"), deps)
+    if action == "upsert":
+        return cmd_agents_upsert(args, deps)
+    if action == "delete":
+        return cmd_agents_delete(getattr(args, "id"), getattr(args, "yes", False), deps)
+
+    deps.print_error(
+        "Unknown Subcommand",
+        f"'nmem agents {action}' is not a recognized command.",
+        "Available: nmem agents list|show|upsert|delete",
+    )
+    return 1
+
+
+def cmd_agents_list(deps: AgentProfileCommandDeps) -> int:
+    data = deps.api_get("/settings/agent-profiles")
+    profiles = _profiles_from_response(data)
+    if deps.is_json_mode():
+        deps.output_json(data)
+        return 0
+
+    if not profiles:
+        deps.console.print("[dim]No named agent identities yet.[/dim]")
+        deps.console.print(
+            "[dim]Connected tools still receive a derived default identity through Context Bundle.[/dim]"
+        )
+        return 0
+
+    table = Table(box=box.SIMPLE, header_style="bold", show_edge=False)
+    table.add_column("ID", style="cyan")
+    table.add_column("Name")
+    table.add_column("Role")
+    table.add_column("Default Space")
+    table.add_column("Source")
+    table.add_column("Host ID")
+    table.add_column("Tags")
+    for profile in profiles:
+        table.add_row(
+            str(profile.get("id", "")),
+            str(profile.get("displayName", "")),
+            str(profile.get("role") or "general"),
+            str(profile.get("defaultSpaceId") or "default"),
+            str(profile.get("sourceApp") or ""),
+            str(profile.get("hostAgentId") or ""),
+            ", ".join(_list_of_strings(profile.get("tags"))),
+        )
+    deps.console.print(table)
+    return 0
+
+
+def cmd_agents_show(agent_id: str, deps: AgentProfileCommandDeps) -> int:
+    profile = _find_profile(agent_id, deps)
+    if profile is None:
+        return _not_found(agent_id, deps)
+    if deps.is_json_mode():
+        deps.output_json(profile)
+        return 0
+
+    deps.console.print()
+    deps.console.print(f"[bold]{profile.get('displayName') or profile.get('id')}[/bold]")
+    deps.console.print(f"  ID:            {profile.get('id', '')}")
+    deps.console.print(f"  Role:          {profile.get('role') or 'general'}")
+    deps.console.print(f"  Default Space: {profile.get('defaultSpaceId') or 'default'}")
+    if profile.get("sourceApp"):
+        deps.console.print(f"  Source App:    {profile.get('sourceApp')}")
+    if profile.get("hostAgentId"):
+        deps.console.print(f"  Host Agent ID: {profile.get('hostAgentId')}")
+    tags = ", ".join(_list_of_strings(profile.get("tags")))
+    if tags:
+        deps.console.print(f"  Tags:          {tags}")
+    if profile.get("description"):
+        deps.console.print()
+        deps.console.print(str(profile.get("description")))
+    if profile.get("instructions"):
+        deps.console.print()
+        deps.console.print("[bold]Agent Rules[/bold]")
+        deps.console.print(str(profile.get("instructions")))
+    deps.console.print()
+    return 0
+
+
+def cmd_agents_upsert(args: argparse.Namespace, deps: AgentProfileCommandDeps) -> int:
+    agent_id = str(getattr(args, "id", "")).strip()
+    payload = _payload_from_args(args)
+    exists = _find_profile(agent_id, deps) is not None
+    if exists:
+        saved = deps.api_put(
+            f"/settings/agent-profiles/{quote(agent_id, safe='')}",
+            payload,
+        )
+        action = "Updated"
+    else:
+        saved = deps.api_post("/settings/agent-profiles", payload)
+        action = "Created"
+
+    if deps.is_json_mode():
+        deps.output_json(saved)
+    else:
+        deps.print_success(action, f"{saved.get('id', agent_id)}")
+    return 0
+
+
+def cmd_agents_delete(
+    agent_id: str,
+    yes: bool,
+    deps: AgentProfileCommandDeps,
+) -> int:
+    if not yes:
+        if deps.is_json_mode():
+            deps.output_json(
+                {
+                    "error": "confirmation_required",
+                    "message": "Pass --yes to delete an agent identity in JSON mode.",
+                }
+            )
+            return 1
+        if not deps.confirm(f"Delete agent identity '{agent_id}'?"):
+            deps.console.print("[dim]Cancelled.[/dim]")
+            return 0
+
+    result = deps.api_delete(f"/settings/agent-profiles/{quote(agent_id, safe='')}")
+    if deps.is_json_mode():
+        deps.output_json(result)
+    else:
+        deps.print_success("Deleted", agent_id)
+    return 0
+
+
+def _profiles_from_response(data: dict[str, Any]) -> list[dict[str, Any]]:
+    raw = data.get("agentProfiles", [])
+    if not isinstance(raw, list):
+        return []
+    return [item for item in raw if isinstance(item, dict)]
+
+
+def _find_profile(agent_id: str, deps: AgentProfileCommandDeps) -> dict[str, Any] | None:
+    data = deps.api_get("/settings/agent-profiles")
+    for profile in _profiles_from_response(data):
+        if str(profile.get("id")) == agent_id:
+            return profile
+    return None
+
+
+def _payload_from_args(args: argparse.Namespace) -> dict[str, Any]:
+    payload: dict[str, Any] = {"id": str(getattr(args, "id", "")).strip()}
+    field_map = {
+        "display_name": "displayName",
+        "role": "role",
+        "default_space": "defaultSpaceId",
+        "source_app": "sourceApp",
+        "host_agent_id": "hostAgentId",
+        "description": "description",
+        "instructions": "instructions",
+    }
+    for attr, key in field_map.items():
+        value = getattr(args, attr, None)
+        if isinstance(value, str) and value.strip():
+            payload[key] = value.strip()
+    tags = _normalize_tags(getattr(args, "tags", []), getattr(args, "tags_csv", None))
+    if tags:
+        payload["tags"] = tags
+    return payload
+
+
+def _normalize_tags(repeated: list[str] | None, csv: str | None) -> list[str]:
+    values: list[str] = []
+    for raw in repeated or []:
+        values.extend(str(raw).split(","))
+    if csv:
+        values.extend(csv.split(","))
+
+    seen: set[str] = set()
+    tags: list[str] = []
+    for raw in values:
+        tag = raw.strip()
+        if not tag or tag in seen:
+            continue
+        seen.add(tag)
+        tags.append(tag[:80])
+        if len(tags) >= 20:
+            break
+    return tags
+
+
+def _list_of_strings(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item) for item in value if str(item).strip()]
+
+
+def _not_found(agent_id: str, deps: AgentProfileCommandDeps) -> int:
+    if deps.is_json_mode():
+        deps.output_json({"error": "not_found", "id": agent_id})
+    else:
+        deps.print_error(
+            "Agent Not Found",
+            f"No agent identity named '{agent_id}'.",
+            "Run `nmem agents list` to see configured identities.",
+        )
+    return 1