Merge pull request #134 from frostming/fix/process-out

refactor: streamline error messages and command execution in NmemClient

Author: wey-gu

nowledge-mem-bub-plugin/src/nowledge_mem_bub/client.py

@@ -74,9 +74,7 @@ def _resolve_cmd(self) -> str:
         if cmd:
             self._cmd = cmd
             return cmd
-        raise NmemError(
-            "nmem not found in PATH. Install with: pip install nmem-cli"
-        )
+        raise NmemError("nmem not found in PATH. Install with: pip install nmem-cli")
 
     def _build_env(self) -> dict[str, str]:
         env = dict(os.environ)
@@ -109,17 +107,15 @@ async def _exec(
                 stderr=asyncio.subprocess.PIPE,
                 env=self._build_env(),
             )
-            stdout, stderr = await asyncio.wait_for(
-                proc.communicate(), timeout=timeout
-            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=timeout)
         except asyncio.TimeoutError:
             proc.kill()  # type: ignore[union-attr]
             raise NmemError(f"nmem timed out after {timeout}s")
         except FileNotFoundError:
             raise NmemError("nmem not found in PATH")
 
         if proc.returncode != 0:
-            err = stderr.decode(errors="replace").strip()
+            err = (stderr or stdout).decode(errors="replace").strip()
             raise NmemError(f"nmem exited {proc.returncode}: {err}")
 
         return stdout.decode(errors="replace").strip()
@@ -229,9 +225,7 @@ async def graph_expand(
         return result if isinstance(result, dict) else {}
 
     async def graph_evolves(self, memory_id: str, limit: int = 10) -> dict:
-        result = await self._exec_json(
-            "g", "evolves", memory_id, "-n", str(limit)
-        )
+        result = await self._exec_json("g", "evolves", memory_id, "-n", str(limit))
         return result if isinstance(result, dict) else {}
 
     # ------------------------------------------------------------------
@@ -287,14 +281,26 @@ async def create_thread(
         self, thread_id: str, title: str, messages_json: str
     ) -> dict:
         result = await self._exec_json(
-            "t", "create", "--id", thread_id, "-t", title,
-            "-m", messages_json, "-s", "bub",
+            "t",
+            "create",
+            "--id",
+            thread_id,
+            "-t",
+            title,
+            "-m",
+            messages_json,
+            "-s",
+            "bub",
         )
         return result if isinstance(result, dict) else {}
 
     async def append_thread(self, thread_id: str, messages_json: str) -> dict:
         result = await self._exec_json(
-            "t", "append", thread_id, "-m", messages_json,
+            "t",
+            "append",
+            thread_id,
+            "-m",
+            messages_json,
         )
         return result if isinstance(result, dict) else {}
 

nowledge-mem-bub-plugin/src/nowledge_mem_bub/plugin.py

@@ -10,17 +10,15 @@
 
 import hashlib
 import json
-import logging
 import os
 from typing import Any
 
 from bub import hookimpl
 from bub.envelope import content_of
+from loguru import logger
 
 from .client import NmemClient, NmemError
 
-logger = logging.getLogger(__name__)
-
 # ---------------------------------------------------------------------------
 # Behavioural guidance injected into the system prompt.
 # Cost: ~50 tokens.  Adjusts when session_context is on to avoid redundant
@@ -138,7 +136,7 @@ async def _load_memory(self, message) -> tuple[str, list[dict[str, Any]]]:
             # mem.context or mem.search on demand.
             return "", []
         if not self.client.is_available():
-            logger.debug("nmem not in PATH, skipping memory load")
+            logger.warning("nmem not in PATH, skipping memory load")
             return "", []
 
         # Session context mode: fetch WM + recalled memories
@@ -147,15 +145,15 @@ async def _load_memory(self, message) -> tuple[str, list[dict[str, Any]]]:
             wm = await self.client.read_working_memory()
             working_memory = wm.get("content", "")
         except Exception as exc:
-            logger.debug("working memory read failed: %s", exc)
+            logger.warning("working memory read failed: {}", exc)
 
         # Recall: search for memories relevant to the current message
         query = content_of(message)
         if query and len(query.strip()) > 3:
             try:
                 recalled = await self.client.search(query[:500], limit=5)
             except Exception as exc:
-                logger.debug("recall search failed: %s", exc)
+                logger.warning("recall search failed: {}", exc)
 
         return working_memory, recalled
 
@@ -171,20 +169,20 @@ async def save_state(self, session_id, state, message, model_output) -> None:
         if not self.client.is_available():
             return
 
-        try:
-            user_content = content_of(message)
-            if not user_content or not model_output:
-                return
+        user_content = content_of(message)
+        if not user_content or not model_output:
+            return
 
-            digest = hashlib.sha1(session_id.encode()).hexdigest()[:10]
-            thread_id = f"bub-{digest}"
+        digest = hashlib.sha1(session_id.encode()).hexdigest()[:10]
+        thread_id = f"bub-{digest}"
 
-            messages = [
-                {"role": "user", "content": user_content[:800]},
-                {"role": "assistant", "content": str(model_output)[:800]},
-            ]
-            messages_json = json.dumps(messages)
+        messages = [
+            {"role": "user", "content": user_content[:800]},
+            {"role": "assistant", "content": str(model_output)[:800]},
+        ]
+        messages_json = json.dumps(messages)
 
+        try:
             if thread_id in self._known_threads:
                 await self.client.append_thread(thread_id, messages_json)
             else:
@@ -200,7 +198,7 @@ async def save_state(self, session_id, state, message, model_output) -> None:
                     self._known_threads.add(thread_id)
         except Exception as exc:
             # save_state must never raise — it runs in a finally block
-            logger.debug("session capture failed: %s", exc)
+            logger.warning("session capture failed: {}", exc)
 
 
 plugin = NowledgeMemPlugin()