nmem-cli 0.9.22__tar.gz → 0.9.24__tar.gz

{nmem_cli-0.9.22 → nmem_cli-0.9.24}/PKG-INFO

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

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

{nmem_cli-0.9.22 → nmem_cli-0.9.24}/src/nmem_cli/__init__.py

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

{nmem_cli-0.9.22 → nmem_cli-0.9.24}/src/nmem_cli/cli.py

@@ -4517,6 +4517,67 @@ def _parsed_threads_to_import_items(threads: Any) -> list[dict[str, Any]]:
     return items
 
 
+def _thread_authorship_metadata(
+    *,
+    agent_id: str | None = None,
+    source_app: str | None = None,
+    host_agent_id: str | None = None,
+) -> dict[str, str]:
+    """Resolve explicit thread authorship metadata from args/env.
+
+    `source_app` is provenance only. `agent_id` is the portable AI Identity.
+    `host_agent_id` is an advanced external alias used by integrations; the CLI
+    never invents it and never turns source_app into identity.
+    """
+    resolved_agent_id = (agent_id or os.environ.get("NMEM_AGENT_ID") or "").strip()
+    resolved_host_agent_id = (
+        host_agent_id or os.environ.get("NMEM_HOST_AGENT_ID") or ""
+    ).strip()
+    resolved_source_app = (source_app or "").strip()
+
+    metadata: dict[str, str] = {}
+    if resolved_agent_id:
+        metadata["agent_id"] = resolved_agent_id
+    if resolved_source_app:
+        metadata["source_app"] = resolved_source_app
+    if resolved_host_agent_id:
+        metadata["host_agent_id"] = resolved_host_agent_id
+    return metadata
+
+
+def _merge_thread_authorship_metadata(
+    target: dict[str, Any],
+    authorship_metadata: dict[str, str],
+) -> None:
+    if not authorship_metadata:
+        return
+    metadata = target.get("metadata")
+    if not isinstance(metadata, dict):
+        metadata = {}
+    metadata.update(authorship_metadata)
+    target["metadata"] = metadata
+
+
+def _backfill_thread_authorship_metadata(
+    thread_id: str,
+    authorship_metadata: dict[str, str],
+    *,
+    space_id: str | None = None,
+) -> None:
+    if not authorship_metadata:
+        return
+    payload: dict[str, Any] = {
+        "metadata": authorship_metadata,
+        "only_missing": True,
+    }
+    if space_id:
+        payload["space_id"] = space_id
+    api_post_optional(
+        f"/threads/{quote(thread_id, safe='')}/metadata/merge",
+        payload,
+    )
+
+
 def cmd_threads_import(
     file: str | None = None,
     messages_json: str | None = None,
@@ -4525,10 +4586,17 @@ def cmd_threads_import(
     source: str | None = None,
     from_stdin: bool = False,
     space_id: str | None = None,
+    agent_id: str | None = None,
+    host_agent_id: str | None = None,
 ) -> None:
     """Import a thread from file, JSON messages, or stdin."""
     payload: dict[str, Any] = {}
     claude_pending_memories: list[Any] | None = None
+    authorship_metadata = _thread_authorship_metadata(
+        agent_id=agent_id,
+        source_app=source,
+        host_agent_id=host_agent_id,
+    )
 
     if thread_id:
         payload["thread_id"] = thread_id
@@ -4704,6 +4772,15 @@ def cmd_threads_import(
             print_error("Missing Input", "Provide --file, --messages, or --stdin")
         sys.exit(1)
 
+    if authorship_metadata:
+        threads = payload.get("threads")
+        if isinstance(threads, list):
+            for item in threads:
+                if isinstance(item, dict):
+                    _merge_thread_authorship_metadata(item, authorship_metadata)
+        else:
+            _merge_thread_authorship_metadata(payload, authorship_metadata)
+
     if not is_json_mode():
         with Progress(
             SpinnerColumn(),
@@ -5129,6 +5206,8 @@ def cmd_threads_save(
     summary: str | None = None,
     truncate: bool = False,
     space_id: str | None = None,
+    agent_id: str | None = None,
+    host_agent_id: str | None = None,
 ) -> None:
     """Save coding session(s) as conversation thread(s).
 
@@ -5163,6 +5242,12 @@ def cmd_threads_save(
             print_error("Path Not Found", str(resolved_path))
         sys.exit(1)
 
+    authorship_metadata = _thread_authorship_metadata(
+        agent_id=agent_id,
+        source_app=client,
+        host_agent_id=host_agent_id,
+    )
+
     def _save_sessions() -> dict[str, Any]:
         try:
             sessions = discover_sessions(client, str(resolved_path), mode, session_id)
@@ -5197,6 +5282,7 @@ def cmd_threads_save(
                 }
 
             metadata = dict(thread_data.get("metadata") or {})
+            metadata.update(authorship_metadata)
             if index == 0 and summary:
                 metadata["user_summary"] = summary
 
@@ -5230,6 +5316,11 @@ def cmd_threads_save(
                     }
                 )
             else:
+                _backfill_thread_authorship_metadata(
+                    thread_id,
+                    authorship_metadata,
+                    space_id=space_id,
+                )
                 append_data = api_post(
                     f"/threads/{quote(thread_id, safe='')}/append",
                     {
@@ -5311,6 +5402,7 @@ def _write_thread_from_session_data(
     source_app: str,
     space_id: str | None,
     metadata_updates: dict[str, Any] | None = None,
+    authorship_metadata: dict[str, str] | None = None,
     idempotency_prefix: str | None = None,
 ) -> dict[str, Any]:
     external_id_keys = (
@@ -5408,6 +5500,8 @@ def _write_thread_from_session_data(
     metadata = dict(thread_data.get("metadata") or {})
     if metadata_updates:
         metadata.update(metadata_updates)
+    if authorship_metadata:
+        metadata.update(authorship_metadata)
 
     existing_params = {"space_id": space_id} if space_id else None
     existing_thread = api_get_optional(
@@ -5445,6 +5539,11 @@ def _write_thread_from_session_data(
         append_payload.update(metadata_updates)
     if idempotency_prefix:
         append_payload["idempotency_key"] = f"{idempotency_prefix}:{session_id}"
+    _backfill_thread_authorship_metadata(
+        thread_id,
+        authorship_metadata or {},
+        space_id=space_id,
+    )
     append_data = api_post(
         f"/threads/{quote(thread_id, safe='')}/append",
         append_payload,
@@ -5519,6 +5618,8 @@ def cmd_threads_sync(
     truncate: bool = False,
     space_id: str | None = None,
     source_roots: list[str] | None = None,
+    agent_id: str | None = None,
+    host_agent_id: str | None = None,
 ) -> None:
     """Preview or import historical sessions for a supported local agent host."""
     if client not in SUPPORTED_SESSION_CLIENTS:
@@ -5548,7 +5649,14 @@ def cmd_threads_sync(
     # These clients have one local session store, so they can safely preview all
     # sessions by default. Cursor stays cwd-scoped unless the caller gives an
     # explicit transcript root; then the root itself is the user's selected scope.
-    default_all_projects_clients = {"hermes", "kimi-code", "mimo-code", "omp", "pi"}
+    default_all_projects_clients = {
+        "hermes",
+        "kimi-code",
+        "kimi-work",
+        "mimo-code",
+        "omp",
+        "pi",
+    }
     discovery_path = project_path
     if all_projects:
         discovery_path = "__all__"
@@ -5571,6 +5679,12 @@ def cmd_threads_sync(
             print_error("Path Not Found", str(resolved_path))
         sys.exit(1)
 
+    authorship_metadata = _thread_authorship_metadata(
+        agent_id=agent_id,
+        source_app=client,
+        host_agent_id=host_agent_id,
+    )
+
     try:
         sessions = discover_sessions(
             client,
@@ -5643,6 +5757,7 @@ def cmd_threads_sync(
                         "analysis": "searchable-now-distill-on-demand",
                         "sync_reason": "history_sync",
                     },
+                    authorship_metadata=authorship_metadata,
                     idempotency_prefix=f"{client}:history",
                 )
             )
@@ -9782,6 +9897,7 @@ _MCP_HOST_APPS = {
     "claude-code": "Claude Code",
     "claude-desktop": "Claude",
     "kimi-code": "Kimi Code",
+    "kimi-work": "Kimi Work",
     "zcode": "ZCode",
     "mimo-code": "MiMo Code",
     "omp": "OMP",
@@ -10737,6 +10853,14 @@ PRIORITY
             action="store_true",
             help="Read conversation markdown from stdin",
         )
+        imp.add_argument(
+            "--agent-id",
+            help="Explicit Nowledge AI Identity id/slug for imported threads",
+        )
+        imp.add_argument(
+            "--host-agent-id",
+            help=argparse.SUPPRESS,
+        )
 
         a = thr_subs.add_parser(
             "append",
@@ -10839,7 +10963,7 @@ PRIORITY
         sv = thr_subs.add_parser(
             "save",
             help=(
-                "Save Claude Code, Codex, Cursor, Gemini CLI, Kimi Code, "
+                "Save Claude Code, Codex, Cursor, Gemini CLI, Kimi Code/Kimi Work, "
                 "OpenCode-family, Pi/OMP, or Hermes session as thread"
             ),
             parents=[_space_parent],
@@ -10849,6 +10973,7 @@ PRIORITY
   nmem t save --from codex --session-id sess_abc123
   nmem t save --from cursor -p /path/to/project
   nmem t save --from kimi-code --session-id sess_abc123
+  nmem t save --from kimi-work --session-id conv_abc123
   nmem t save --from mimo-code --session-id ses_abc123
   nmem t save --from omp -p /path/to/project
   nmem t save --from opencode -p /path/to/project
@@ -10887,6 +11012,14 @@ PRIORITY
             action="store_true",
             help="Truncate large tool results (>10KB)",
         )
+        sv.add_argument(
+            "--agent-id",
+            help="Explicit Nowledge AI Identity id/slug for saved sessions",
+        )
+        sv.add_argument(
+            "--host-agent-id",
+            help=argparse.SUPPRESS,
+        )
 
         sync = thr_subs.add_parser(
             "sync",
@@ -10896,6 +11029,7 @@ PRIORITY
   nmem t sync --from pi
   nmem t sync --from pi --apply
   nmem t sync --from kimi-code --apply
+  nmem t sync --from kimi-work --apply
   nmem t sync --from mimo-code --apply
   nmem t sync --from omp --apply
   nmem t sync --from cursor --all-projects --limit 20
@@ -10920,8 +11054,8 @@ PRIORITY
             default=None,
             help=(
                 "Project directory path. Defaults to all sessions for global-store "
-                "hosts (Hermes, Kimi Code, MiMo Code, OMP, Pi), and current "
-                "directory for other clients."
+                "hosts (Hermes, Kimi Code, Kimi Work, MiMo Code, OMP, Pi), "
+                "and current directory for other clients."
             ),
         )
         sync.add_argument(
@@ -10951,6 +11085,14 @@ PRIORITY
             action="store_true",
             help="Truncate large tool results where supported",
         )
+        sync.add_argument(
+            "--agent-id",
+            help="Explicit Nowledge AI Identity id/slug for synced sessions",
+        )
+        sync.add_argument(
+            "--host-agent-id",
+            help=argparse.SUPPRESS,
+        )
 
         # triage - Check if conversation is worth distilling
         tr = thr_subs.add_parser(
@@ -12101,6 +12243,8 @@ def main() -> int:
                 source=getattr(args, "source", None),
                 from_stdin=getattr(args, "stdin", False),
                 space_id=getattr(args, "space", None),
+                agent_id=getattr(args, "agent_id", None),
+                host_agent_id=getattr(args, "host_agent_id", None),
             )
         elif action == "append":
             cmd_threads_append(
@@ -12140,6 +12284,8 @@ def main() -> int:
                 summary=getattr(args, "summary", None),
                 truncate=getattr(args, "truncate", False),
                 space_id=getattr(args, "space", None),
+                agent_id=getattr(args, "agent_id", None),
+                host_agent_id=getattr(args, "host_agent_id", None),
             )
         elif action == "sync":
             cmd_threads_sync(
@@ -12152,6 +12298,8 @@ def main() -> int:
                 truncate=getattr(args, "truncate", False),
                 space_id=getattr(args, "space", None),
                 source_roots=getattr(args, "session_dirs", None),
+                agent_id=getattr(args, "agent_id", None),
+                host_agent_id=getattr(args, "host_agent_id", None),
             )
         elif action == "triage":
             cmd_threads_triage(

{nmem_cli-0.9.22 → nmem_cli-0.9.24}/src/nmem_cli/session_import.py

@@ -7,7 +7,7 @@ without importing server internals.
 
 Maintenance rule:
 - if Claude Code, Codex/Cursor/Grok, Gemini CLI, OpenCode-family agents,
-  Kimi Code, Pi/OMP, or Hermes change their transcript formats or storage
+  Kimi Code/Kimi Work, Pi/OMP, or Hermes change their transcript formats or storage
   layout, update this client module and the corresponding server-local
   parser/import path in the same change
 - keep the normalized thread output aligned across both sides
@@ -38,6 +38,7 @@ SUPPORTED_SESSION_CLIENTS = (
     "grok",
     "gemini-cli",
     "kimi-code",
+    "kimi-work",
     "mimo-code",
     "omp",
     "opencode",
@@ -230,8 +231,13 @@ def discover_sessions(
         candidates = _discover_grok_sessions(project_path, session_id)
     elif client == "gemini-cli":
         candidates = _discover_gemini_sessions(project_path, session_id)
-    elif client == "kimi-code":
-        candidates = _discover_kimi_sessions(project_path, session_id, source_roots)
+    elif client in {"kimi-code", "kimi-work"}:
+        candidates = _discover_kimi_sessions(
+            project_path,
+            session_id,
+            source_roots,
+            source_app=client,
+        )
     elif client == "mimo-code":
         candidates = _discover_mimo_code_sessions(project_path, session_id, source_roots)
     elif client == "omp":
@@ -271,6 +277,8 @@ def parse_session(
         return parse_gemini_session(file_path)
     if client == "kimi-code":
         return parse_kimi_code_session(file_path)
+    if client == "kimi-work":
+        return parse_kimi_work_session(file_path)
     if client == "mimo-code":
         return parse_mimo_code_session(file_path, session_id=session_id)
     if client == "omp":
@@ -1134,10 +1142,32 @@ def _discover_mimo_code_sessions(
     return candidates
 
 
-def _get_kimi_session_roots(source_roots: Optional[list[str]] = None) -> list[Path]:
+def _get_kimi_work_home() -> Path:
+    return _env_path(
+        "KIMI_WORK_HOME",
+        Path.home()
+        / "Library"
+        / "Application Support"
+        / "kimi-desktop"
+        / "daimon-share"
+        / "daimon"
+        / "runtime"
+        / "kimi-code"
+        / "home",
+    )
+
+
+def _get_kimi_session_roots(
+    source_roots: Optional[list[str]] = None,
+    *,
+    source_app: str = "kimi-code",
+) -> list[Path]:
     if source_roots:
         return [Path(root).expanduser() for root in source_roots]
-    kimi_home = _env_path("KIMI_CODE_HOME", Path.home() / ".kimi-code")
+    if source_app == "kimi-work":
+        kimi_home = _get_kimi_work_home()
+    else:
+        kimi_home = _env_path("KIMI_CODE_HOME", Path.home() / ".kimi-code")
     return [kimi_home / "sessions"]
 
 
@@ -1151,7 +1181,11 @@ def _kimi_session_dir_from_wire(wire_path: Path) -> Path:
     return wire_path.parent
 
 
-def _iter_kimi_session_dirs(source_roots: Optional[list[str]] = None) -> list[Path]:
+def _iter_kimi_session_dirs(
+    source_roots: Optional[list[str]] = None,
+    *,
+    source_app: str = "kimi-code",
+) -> list[Path]:
     session_dirs: list[Path] = []
     seen: set[Path] = set()
 
@@ -1168,7 +1202,7 @@ def _iter_kimi_session_dirs(source_roots: Optional[list[str]] = None) -> list[Pa
             seen.add(resolved)
             session_dirs.append(candidate)
 
-    for root in _get_kimi_session_roots(source_roots):
+    for root in _get_kimi_session_roots(source_roots, source_app=source_app):
         if not root.exists():
             continue
         if root.is_file() and root.name == "wire.jsonl":
@@ -1278,6 +1312,7 @@ def _kimi_messages_from_events(
     events: list[dict[str, Any]],
     *,
     session_id: str,
+    source_app: str = "kimi-code",
 ) -> tuple[list[dict[str, Any]], Optional[str]]:
     messages: list[dict[str, Any]] = []
     first_user_content: Optional[str] = None
@@ -1296,8 +1331,8 @@ def _kimi_messages_from_events(
                     "timestamp": assistant_timestamp,
                     "metadata": {
                         "external_id": assistant_external_id
-                        or f"kimi-code-{session_id}-assistant-{len(messages)}",
-                        "source_app": "kimi-code",
+                        or f"{source_app}-{session_id}-assistant-{len(messages)}",
+                        "source_app": source_app,
                     },
                 }
             )
@@ -1332,8 +1367,8 @@ def _kimi_messages_from_events(
                     "content": content,
                     "timestamp": timestamp,
                     "metadata": {
-                        "external_id": f"kimi-code-{session_id}-message-{index}",
-                        "source_app": "kimi-code",
+                        "external_id": f"{source_app}-{session_id}-message-{index}",
+                        "source_app": source_app,
                         "kimi_event_type": event_type,
                         "kimi_message_role": role,
                     },
@@ -1353,7 +1388,7 @@ def _kimi_messages_from_events(
                 continue
             if not assistant_chunks:
                 assistant_timestamp = timestamp
-                assistant_external_id = f"kimi-code-{session_id}-loop-{index}"
+                assistant_external_id = f"{source_app}-{session_id}-loop-{index}"
             assistant_chunks.append(part_text)
         elif loop_type in {"step.end", "message.end", "turn.end"}:
             flush_assistant()
@@ -1366,6 +1401,8 @@ def _discover_kimi_sessions(
     project_path: str,
     target_session_id: Optional[str],
     source_roots: Optional[list[str]] = None,
+    *,
+    source_app: str = "kimi-code",
 ) -> list[SessionCandidate]:
     all_projects = _is_all_projects_path(project_path)
     normalized_project_path = (
@@ -1373,7 +1410,8 @@ def _discover_kimi_sessions(
     )
     candidates: list[SessionCandidate] = []
 
-    for session_dir in _iter_kimi_session_dirs(source_roots):
+    display_name = "Kimi Work" if source_app == "kimi-work" else "Kimi Code"
+    for session_dir in _iter_kimi_session_dirs(source_roots, source_app=source_app):
         try:
             session_id = session_dir.name
             if target_session_id and session_id != target_session_id:
@@ -1388,7 +1426,11 @@ def _discover_kimi_sessions(
             ):
                 continue
 
-            messages, _ = _kimi_messages_from_events(events, session_id=session_id)
+            messages, _ = _kimi_messages_from_events(
+                events,
+                session_id=session_id,
+                source_app=source_app,
+            )
             user_messages = sum(1 for msg in messages if msg["role"] == "user")
             assistant_messages = sum(
                 1 for msg in messages if msg["role"] == "assistant"
@@ -1417,7 +1459,8 @@ def _discover_kimi_sessions(
             )
         except Exception as exc:
             logger.warning(
-                "Failed to analyze Kimi Code session %s: %s",
+                "Failed to analyze %s session %s: %s",
+                display_name,
                 session_dir,
                 exc,
             )
@@ -2544,7 +2587,12 @@ def parse_omp_session(file_path: Path) -> dict[str, Any]:
     }
 
 
-def parse_kimi_code_session(session_path: Path) -> dict[str, Any]:
+def _parse_kimi_family_session(
+    session_path: Path,
+    *,
+    source_app: str,
+    display_name: str,
+) -> dict[str, Any]:
     session_dir = (
         _kimi_session_dir_from_wire(session_path)
         if session_path.is_file()
@@ -2556,16 +2604,17 @@ def parse_kimi_code_session(session_path: Path) -> dict[str, Any]:
     messages, first_user_content = _kimi_messages_from_events(
         events,
         session_id=session_id,
+        source_app=source_app,
     )
     if not messages:
         raise SessionImportError(
-            "No valid user/assistant messages found in Kimi Code session"
+            f"No valid user/assistant messages found in {display_name} session"
         )
     if not any(msg["role"] == "user" for msg in messages) or not any(
         msg["role"] == "assistant" for msg in messages
     ):
         raise SessionImportError(
-            "Kimi Code session needs at least one user and one assistant message"
+            f"{display_name} session needs at least one user and one assistant message"
         )
 
     cwd = _kimi_cwd_from_events(events) or _kimi_string(state.get("cwd"))
@@ -2574,22 +2623,24 @@ def parse_kimi_code_session(session_path: Path) -> dict[str, Any]:
         if first_user_content:
             title = first_user_content[:120].replace("\n", " ").strip()
         elif cwd:
-            title = f"Kimi Code session - {os.path.basename(cwd.rstrip('/' + chr(92)))}"
+            title = f"{display_name} session - {os.path.basename(cwd.rstrip('/' + chr(92)))}"
         else:
-            title = f"Kimi Code session - {session_id}"
+            title = f"{display_name} session - {session_id}"
 
     sanitized_session_id = re.sub(r"[^a-z0-9._-]+", "-", session_id.lower())
     project_name = os.path.basename(cwd.rstrip("/" + chr(92))) if cwd else None
+    metadata_session_key = f"{source_app.replace('-', '_')}_session_id"
     return {
-        "thread_id": f"kimi-code-{sanitized_session_id}",
+        "thread_id": f"{source_app}-{sanitized_session_id}",
         "title": title,
         "messages": messages,
-        "source": "kimi-code",
+        "source": source_app,
         "project": project_name,
         "workspace": cwd,
         "metadata": {
             "session_id": session_id,
-            "kimi_code_session_id": session_id,
+            metadata_session_key: session_id,
+            "runtime_family": "kimi-code",
             "created_at": state.get("createdAt") or state.get("created_at"),
             "updated_at": state.get("updatedAt") or state.get("updated_at"),
             "last_prompt": state.get("lastPrompt"),
@@ -2600,6 +2651,22 @@ def parse_kimi_code_session(session_path: Path) -> dict[str, Any]:
     }
 
 
+def parse_kimi_code_session(session_path: Path) -> dict[str, Any]:
+    return _parse_kimi_family_session(
+        session_path,
+        source_app="kimi-code",
+        display_name="Kimi Code",
+    )
+
+
+def parse_kimi_work_session(session_path: Path) -> dict[str, Any]:
+    return _parse_kimi_family_session(
+        session_path,
+        source_app="kimi-work",
+        display_name="Kimi Work",
+    )
+
+
 def parse_hermes_session(
     db_path: Path,
     *,