superlocalmemory 3.8.3 → 3.8.6

package/src/superlocalmemory/storage/write_lock.py

@@ -0,0 +1,88 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com
+
+"""Process-level per-path write-lock registry for memory.db.
+
+ALL code that writes to a given SQLite file MUST acquire the lock returned
+by ``get_write_lock(db_path)`` BEFORE opening a sqlite3 connection for
+writing.  This serialises writes at the Python layer so that only ONE
+sqlite3 connection holds the SQLite WAL write lock at any instant, which
+eliminates all SQLITE_BUSY retries within the process.
+
+Invariant
+---------
+Every memory.db write path in the process acquires the same RLock before
+touching sqlite3.  Because SQLite WAL mode allows one writer at a time, a
+Python-level RLock gives us the same serialisation guarantee while
+completely avoiding the SQLITE_BUSY / busy_timeout retry loop.
+
+Lock ordering rule (must never be violated)
+-------------------------------------------
+    get_write_lock(memory.db)  ←  OUTERMOST
+        ↳  VectorStore._lock   (inner — VectorStore in-memory state)
+            ↳  sqlite3 write transaction (BEGIN … COMMIT)
+
+Re-entrancy
+-----------
+``threading.RLock`` is used so that the same thread can re-acquire the
+lock without deadlocking.  This is required by the self-heal backfill
+pattern::
+
+    with db._lock:          # db._lock IS get_write_lock(memory.db)
+        vs.upsert(...)      # also calls get_write_lock → re-entrant OK
+
+Usage
+-----
+    from superlocalmemory.storage.write_lock import get_write_lock
+
+    with get_write_lock(db_path):
+        conn = sqlite3.connect(str(db_path))
+        conn.execute("INSERT INTO ...")
+        conn.commit()
+        conn.close()
+"""
+from __future__ import annotations
+
+import threading
+from pathlib import Path
+
+# Registry: resolved absolute path string → RLock.
+# Protected by its own Lock so the registry itself is thread-safe.
+_registry: dict[str, threading.RLock] = {}
+_registry_lock = threading.Lock()
+
+
+def get_write_lock(db_path: str | Path) -> threading.RLock:
+    """Return the process-level write-serialisation RLock for *db_path*.
+
+    Resolves the path to its canonical absolute form before hashing so
+    that relative paths, ``.`` components, and symlinks all map to the
+    same lock as their resolved target.  Creates a new ``RLock`` on first
+    call for each unique resolved path.  Thread-safe.
+
+    Parameters
+    ----------
+    db_path:
+        Path to the SQLite database file.  The file need not exist yet.
+
+    Returns
+    -------
+    threading.RLock
+        The shared write-serialisation lock for *db_path*.  All writers
+        of this file in the current process share the same object.
+    """
+    p = Path(db_path)
+    try:
+        key = str(p.resolve())
+    except OSError:
+        # File doesn't exist yet; use absolute path as best-effort key.
+        key = str(p.absolute())
+
+    with _registry_lock:
+        if key not in _registry:
+            _registry[key] = threading.RLock()
+        return _registry[key]
+
+
+__all__ = ["get_write_lock"]

package/src/superlocalmemory/ui/index.html

@@ -1578,7 +1578,7 @@
     <script src="static/js/od-skills.js?v=379"></script>
     <script src="static/js/od-mesh.js?v=379"></script>
     <script src="static/js/od-optimize.js?v=379"></script>
-    <script src="static/js/od-settings.js?v=382"></script>
+    <script src="static/js/od-settings.js?v=386"></script>
     <script src="static/js/od-backup.js?v=379"></script>
     <!-- MCP & Integrations pane (v3.8.0): shows exposed MCP tool profile + counts -->
     <script src="static/js/od-mcp.js?v=380"></script>

package/src/superlocalmemory/ui/js/auto-settings.js

@@ -463,7 +463,10 @@ async function saveAllSettings() {
 async function loadEmbeddingSettings() {
     try {
         var resp = await fetch('/api/v3/embedding/config');
-        if (!resp.ok) return;
+        if (!resp.ok) {
+            showEmbeddingConfigUnavailable();
+            return;
+        }
         var data = await resp.json();
 
         var provEl = document.getElementById('settings-emb-provider');
@@ -495,9 +498,19 @@ async function loadEmbeddingSettings() {
         }
     } catch (e) {
         console.log('Load embedding settings error:', e);
+        showEmbeddingConfigUnavailable();
     }
 }
 
+function showEmbeddingConfigUnavailable() {
+    var info = document.getElementById('settings-emb-info');
+    if (!info) return;
+    // Do not alter any form values here: rendering fallback values would make
+    // a transient daemon/config failure look like a valid Mode A setup.
+    info.textContent = 'Embedding configuration unavailable. Check daemon health and retry.';
+    info.className = 'text-warning small';
+}
+
 function updateEmbeddingUI() {
     var provider = document.getElementById('settings-emb-provider')?.value || 'default';
     var isCustom = provider === 'openai';

package/src/superlocalmemory/ui/js/od-settings.js

@@ -368,9 +368,12 @@
     ]);
   }
   function loadEmb() {
-    fetch('/api/v3/embedding/config').then(function (r) { return r.ok ? r.json() : null; })
+    fetch('/api/v3/embedding/config').then(function (r) {
+      if (!r.ok) throw new Error('embedding config unavailable');
+      return r.json();
+    })
       .then(function (d) {
-        if (!d) return;
+        if (!d) throw new Error('embedding config unavailable');
         var p = q('emb-prov');
         if (p) { p.value = d.is_openai_compatible ? 'openai' : 'default'; p.dispatchEvent(new Event('change')); }
         var m = q('emb-model'); if (m) m.value = d.model_name || '';
@@ -378,7 +381,10 @@
         var ep = q('emb-endpoint'); if (ep) ep.value = d.api_endpoint || '';
         var inf = q('emb-info');
         if (inf) inf.textContent = 'Current: ' + (d.model_name || 'nomic-embed-text') + ' (' + (d.dimension || 768) + 'd)';
-      }).catch(function () {});
+      }).catch(function () {
+        var inf = q('emb-info');
+        if (inf) inf.textContent = 'Embedding configuration unavailable. Check daemon health and retry.';
+      });
   }
   function saveEmb() {
     setSt('emb', 'Saving…', null);