superlocalmemory 3.6.13 → 3.6.14

package/src/superlocalmemory/core/config.py

@@ -21,6 +21,16 @@ logger = logging.getLogger(__name__)
 from superlocalmemory.storage.models import Mode
 
 
+# ---------------------------------------------------------------------------
+# Canonical limits (WP-02 — single source of truth across all surfaces)
+# ---------------------------------------------------------------------------
+
+#: Default number of results returned by recall across MCP, CLI, daemon, and
+#: engine.  All surfaces bind their ``limit`` defaults to this constant so a
+#: single change is sufficient to keep the full stack in sync.
+CANONICAL_RECALL_LIMIT: int = 20
+
+
 # ---------------------------------------------------------------------------
 # Default Paths
 # ---------------------------------------------------------------------------
@@ -739,17 +749,32 @@ class SLMConfig:
     @classmethod
     def load(cls, config_path: Path | None = None) -> SLMConfig:
         """Load config from JSON file. Returns default Mode A if file doesn't exist."""
-        path = config_path or (DEFAULT_BASE_DIR / "config.json")
+        # WP-07: resolve base dir through slm_home() at call time so all 3 env
+        # aliases (SLM_DATA_DIR → SL_MEMORY_PATH → SLM_HOME) are honoured.
+        try:
+            from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+            _runtime_base = _slm_home()
+        except Exception:
+            _runtime_base = DEFAULT_BASE_DIR
+        path = config_path or (_runtime_base / "config.json")
         if not path.exists():
             return cls.for_mode(Mode.A)
         import json
-        data = json.loads(path.read_text())
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError) as exc:
+            # An already-corrupt/truncated config.json must NOT brick every `slm`
+            # call — degrade to the Mode-A default and warn rather than raise.
+            logger.warning(
+                "config.json unreadable/corrupt (%s) — using Mode A default", exc
+            )
+            return cls.for_mode(Mode.A)
         mode = Mode(data.get("mode", "a"))
         llm_data = data.get("llm", {})
         emb_data = data.get("embedding", {})
         # V3.5.9: read base_dir before constructing config so for_mode() builds
         # db_path from the user's directory, not DEFAULT_BASE_DIR.
-        raw_base_dir = Path(data.get("base_dir", str(DEFAULT_BASE_DIR)))
+        raw_base_dir = Path(data.get("base_dir", str(_runtime_base)))
         config = cls.for_mode(
             mode,
             llm_provider=llm_data.get("provider", ""),
@@ -932,7 +957,12 @@ class SLMConfig:
             if key in existing:
                 data[key] = existing[key]
 
-        path.write_text(json.dumps(data, indent=2))
+        # Atomic write: a crash mid-write must NOT leave a truncated/corrupt
+        # config.json (which would make every subsequent `slm` call fail to load).
+        import os as _os
+        _tmp = path.with_suffix(path.suffix + ".tmp")
+        _tmp.write_text(json.dumps(data, indent=2))
+        _os.replace(_tmp, path)
 
     @staticmethod
     def provider_presets() -> dict[str, dict[str, str]]:
@@ -987,7 +1017,15 @@ class SLMConfig:
         embedding_dimension: int = 0,
     ) -> SLMConfig:
         """Create config with mode-appropriate defaults."""
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve base dir via slm_home() at call time when not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
 
         if mode == Mode.A:
             # V3.4.24: If user chose "openai" provider, honour their custom
@@ -1130,7 +1168,15 @@ class SLMConfig:
 
         Returns ``\"b\"`` (the default) if the file doesn't exist.
         """
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _f = _base / CURRENT_MODE_FILE
         try:
             return _f.read_text(encoding="utf-8").strip().lower() or "b"
@@ -1140,7 +1186,15 @@ class SLMConfig:
     @staticmethod
     def write_current_mode(mode: str, base_dir: Path | None = None) -> None:
         """Write the current mode letter to ``current_mode``."""
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _base.mkdir(parents=True, exist_ok=True)
         (_base / CURRENT_MODE_FILE).write_text(
             mode.lower().strip(), encoding="utf-8",
@@ -1175,7 +1229,15 @@ class SLMConfig:
         import dataclasses
 
         from superlocalmemory.storage.models import Mode as _M
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _base.mkdir(parents=True, exist_ok=True)
 
         old_config = cls.load(_base / "config.json")
@@ -1242,7 +1304,15 @@ class SLMConfig:
         Called on daemon boot. Idempotent — if ``current_mode`` already
         exists, this is a no-op. Returns True if migration was performed.
         """
-        _base = base_dir or DEFAULT_BASE_DIR
+        # WP-07: resolve via slm_home() at call time when base_dir not explicit.
+        if base_dir is None:
+            try:
+                from superlocalmemory.cli._lazy_init import slm_home as _slm_home
+                _base = _slm_home()
+            except Exception:
+                _base = DEFAULT_BASE_DIR
+        else:
+            _base = base_dir
         _current = _base / CURRENT_MODE_FILE
         if _current.exists():
             return False  # already migrated

package/src/superlocalmemory/core/embeddings.py

@@ -601,8 +601,13 @@ class EmbeddingService:
     def _cloud_embed_batch(
         self, texts: list[str], *, max_retries: int = 3,
     ) -> list[list[float]]:
-        """Encode via Azure OpenAI embedding API with retry."""
-        import httpx
+        """Encode via Azure OpenAI embedding API with retry.
+
+        V3.6.14: Reuses self._get_http_client() (shared persistent connection)
+        instead of creating a fresh httpx.Client per call/retry.  resp.json()
+        is now called inside the try block while the response object is still
+        in scope, eliminating reliance on httpx body-buffering after close.
+        """
         url = (
             f"{self._config.api_endpoint.rstrip('/')}/openai/deployments/"
             f"{self._config.deployment_name}/embeddings"
@@ -613,12 +618,12 @@ class EmbeddingService:
             "api-key": self._config.api_key,
         }
         body = {"input": texts, "model": self._config.deployment_name}
+        client = self._get_http_client()
         last_error: Exception | None = None
         for attempt in range(max_retries):
             try:
-                with httpx.Client(timeout=httpx.Timeout(30.0)) as client:
-                    resp = client.post(url, headers=headers, json=body)
-                    resp.raise_for_status()
+                resp = client.post(url, headers=headers, json=body)
+                resp.raise_for_status()
                 data = resp.json()
                 results = []
                 for item in sorted(data["data"], key=lambda d: d["index"]):

package/src/superlocalmemory/core/engine.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import logging
 from typing import Any
 
-from superlocalmemory.core.config import SLMConfig
+from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT, SLMConfig
 from superlocalmemory.core.engine_capabilities import Capabilities, CapabilityError
 from superlocalmemory.core.modes import get_capabilities
 from superlocalmemory.storage.models import (
@@ -507,7 +507,7 @@ class MemoryEngine:
 
     def recall(
         self, query: str, profile_id: str | None = None,
-        mode: Mode | None = None, limit: int = 20,
+        mode: Mode | None = None, limit: int = CANONICAL_RECALL_LIMIT,
         agent_id: str = "unknown",
         session_id: str | None = None,
         fast: bool = False,

package/src/superlocalmemory/hooks/claude_code_hooks.py

@@ -266,7 +266,12 @@ def _remove_slm_hooks(settings: dict) -> dict:
 
 
 def _read_settings() -> dict:
-    """Read Claude Code settings.json, return empty dict if missing."""
+    """Read Claude Code settings.json, return empty dict if missing.
+
+    Raises:
+        json.JSONDecodeError: propagated as-is when the file exists but is
+            malformed, so callers can distinguish 'missing' from 'corrupt'.
+    """
     if CLAUDE_SETTINGS.exists():
         return json.loads(CLAUDE_SETTINGS.read_text())
     return {}
@@ -356,6 +361,8 @@ def check_status() -> dict:
 
     hook_types_found: list[str] = []
     has_gate = False
+    parse_error: str | None = None
+
     try:
         settings = _read_settings()
         for hook_type, entries in settings.get("hooks", {}).items():
@@ -373,12 +380,26 @@ def check_status() -> dict:
                     break
             if has_gate:
                 break
+    except json.JSONDecodeError as exc:
+        # File exists but is malformed — report indeterminate state so callers
+        # do not conflate 'corrupt' with 'not installed'. Claude Code reads the
+        # file independently; hooks may still be firing even though we cannot
+        # parse the file here (split-brain scenario).
+        parse_error = f"JSON parse error in settings.json: {exc}"
+        logger.warning("SLM: %s", parse_error)
     except Exception:
         pass
 
-    installed = len(hook_types_found) >= 3
+    # Three-valued installed:
+    #   True  — enough SLM hook types found (≥3)
+    #   False — file missing or parseable but no SLM hooks
+    #   None  — file exists but is corrupt (indeterminate)
+    if parse_error is not None:
+        installed: bool | None = None
+    else:
+        installed = len(hook_types_found) >= 3
 
-    return {
+    result: dict = {
         "installed": installed,
         "version": installed_version,
         "latest_version": HOOKS_VERSION,
@@ -386,6 +407,9 @@ def check_status() -> dict:
         "hook_types": hook_types_found,
         "gate_enabled": has_gate,
     }
+    if parse_error is not None:
+        result["error"] = parse_error
+    return result
 
 
 def upgrade_hooks() -> dict: