superlocalmemory 3.4.0 → 3.4.3

package/README.md

@@ -341,20 +341,19 @@ slm dashboard    # Opens at http://localhost:8765
 
 <details open>
 <summary><strong>Dashboard Screenshots</strong> (click to collapse)</summary>
-<p align="center"><img src="docs/screenshots/01-dashboard-main.png" alt="Dashboard" width="600"/></p>
+<p align="center"><img src="docs/screenshots/01-dashboard-main.png" alt="Dashboard Overview — 3,100+ memories, 430K connections" width="600"/></p>
 <p align="center">
-<img src="docs/screenshots/02-knowledge-graph.png" alt="Graph" width="190"/>
-<img src="docs/screenshots/03-math-health.png" alt="Math" width="190"/>
-<img src="docs/screenshots/05-trust-dashboard.png" alt="Trust" width="190"/>
+<img src="docs/screenshots/02-knowledge-graph.png" alt="Knowledge Graph — Sigma.js WebGL with community detection, chat, quick actions, timeline" width="290"/>
+<img src="docs/screenshots/06-graph-communities.png" alt="Graph Communities — Louvain clustering with colored nodes" width="290"/>
 </p>
 <p align="center">
-<img src="docs/screenshots/04-recall-lab.png" alt="Recall" width="190"/>
-<img src="docs/screenshots/06-settings.png" alt="Settings" width="190"/>
-<img src="docs/screenshots/07-memories-blurred.png" alt="Memories" width="190"/>
+<img src="docs/screenshots/03-patterns-learning.png" alt="Patterns — 50 learned behavioral patterns with confidence bars" width="190"/>
+<img src="docs/screenshots/04-learning-dashboard.png" alt="Learning — 722 signals, ML Model phase, tech preferences" width="190"/>
+<img src="docs/screenshots/05-behavioral-analysis.png" alt="Behavioral — pattern analysis with confidence distribution" width="190"/>
 </p>
 </details>
 
-23 tabs: Dashboard, Recall Lab, Knowledge Graph, Memories, Trust Scores, Math Health, Compliance, Learning, IDE Connections, Settings, Memory Lifecycle, Compression, Patterns, and more. Runs locally — no data leaves your machine.
+**v3.4.1 Visual Intelligence:** Sigma.js WebGL knowledge graph with community detection (Louvain/Leiden), 5 quick insight actions, D3 memory timeline, graph-enhanced retrieval (PageRank bias + community boost + contradiction suppression), and 56 auto-mined behavioral patterns. 23+ tabs. Runs locally — no data leaves your machine.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.0",
+  "version": "3.4.3",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",
@@ -89,4 +89,4 @@
   "dependencies": {
     "docx": "^9.5.1"
   }
-}
+}

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.0"
+version = "3.4.3"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}
@@ -49,6 +49,9 @@ dependencies = [
     "tree-sitter-language-pack>=0.3,<2",
     "rustworkx>=0.15,<1",
     "watchdog>=4.0,<6",
+    # V3.4.3: Unified Brain
+    "psutil>=5.9.0",
+    "structlog>=24.0.0,<27.0.0",
 ]
 
 [project.optional-dependencies]
@@ -72,8 +75,14 @@ performance = [
     "diskcache>=5.6.0",
     "orjson>=3.9.0",
 ]
+ingestion = [
+    "keyring>=25.0.0",
+    "google-auth-oauthlib>=1.2.0",
+    "google-api-python-client>=2.100.0",
+    "icalendar>=6.0.0",
+]
 full = [
-    "superlocalmemory[search,ui,learning,performance]",
+    "superlocalmemory[search,ui,learning,performance,ingestion]",
 ]
 dev = [
     "pytest>=8.0",

package/scripts/postinstall.js

@@ -15,7 +15,7 @@ const os = require('os');
 const fs = require('fs');
 
 console.log('\n════════════════════════════════════════════════════════════');
-console.log('  SuperLocalMemory V3 — Post-Installation');
+console.log('  SuperLocalMemory V3 — The Unified Brain');
 console.log('  by Varun Pratap Bhardwaj / Qualixar');
 console.log('  https://github.com/qualixar/superlocalmemory');
 console.log('════════════════════════════════════════════════════════════\n');
@@ -164,6 +164,17 @@ if (pipInstall(perfDeps, 'performance')) {
     console.log('⚠ Performance deps skipped (system works fine without them).');
 }
 
+// V3.4.3: Unified Brain dependencies (health monitor, structured logging, file watching)
+const brainDeps = ['psutil>=5.9.0', 'structlog>=24.0.0', 'watchdog>=4.0.0'];
+console.log('\nInstalling Unified Brain dependencies (health monitor, file watcher)...');
+if (pipInstall(brainDeps, 'brain')) {
+    console.log('✓ Unified Brain deps installed (psutil + structlog + watchdog)');
+    console.log('  Health monitoring, structured logging, and file watching enabled');
+} else {
+    console.log('⚠ Unified Brain deps partially installed (health monitoring may be limited).');
+    console.log('  Run manually: pip install psutil structlog watchdog');
+}
+
 // --- Step 3b: Install the superlocalmemory package itself ---
 // This ensures `python -m superlocalmemory.cli.main` always resolves the
 // correct version, even when invoked outside the Node.js wrapper (e.g.,
@@ -281,13 +292,21 @@ if (setupResult.status === 0) {
 
 // --- Done ---
 console.log('\n════════════════════════════════════════════════════════════');
-console.log('  ✓ SuperLocalMemory V3 installed!');
+console.log('  ✓ SuperLocalMemory V3 — The Unified Brain installed!');
 console.log('');
 console.log('  Quick start:');
-console.log('    slm remember "..."   # Store a memory');
-console.log('    slm recall "..."     # Search memories');
-console.log('    slm dashboard        # Open web dashboard');
-console.log('    slm setup            # Re-run setup wizard');
+console.log('    slm remember "..."        # Store a memory');
+console.log('    slm recall "..."          # Search memories');
+console.log('    slm dashboard             # Open web dashboard');
+console.log('    slm serve                 # Start 24/7 daemon');
+console.log('    slm adapters enable gmail # Enable Gmail ingestion');
+console.log('    slm setup                 # Re-run 9-step wizard');
+console.log('');
+console.log('  New in v3.4.3:');
+console.log('    • Unified daemon (one process, 24/7, < 700MB)');
+console.log('    • SLM Mesh (agent-to-agent P2P built in)');
+console.log('    • Entity compilation (auto knowledge summaries)');
+console.log('    • Ingestion adapters (Gmail, Calendar, Transcripts)');
 console.log('');
-console.log('  Docs: https://github.com/qualixar/superlocalmemory/wiki');
+console.log('  Docs: https://github.com/qualixar/superlocalmemory');
 console.log('════════════════════════════════════════════════════════════\n');

package/src/superlocalmemory/cli/commands.py

@@ -58,6 +58,8 @@ def dispatch(args: Namespace) -> None:
         "reap": cmd_reap,
         # V3.3.21 daemon
         "serve": cmd_serve,
+        # V3.4.3 ingestion adapters
+        "adapters": cmd_adapters,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -110,6 +112,26 @@ def cmd_serve(args: Namespace) -> None:
         print("Failed to start daemon. Check ~/.superlocalmemory/logs/daemon.log")
 
 
+# -- Ingestion Adapters (V3.4.3) ------------------------------------------
+
+
+def cmd_adapters(args: Namespace) -> None:
+    """Manage ingestion adapters (Gmail, Calendar, Transcript).
+
+    Usage:
+      slm adapters list                — show all adapters
+      slm adapters enable <name>       — enable an adapter
+      slm adapters disable <name>      — disable and stop
+      slm adapters start <name>        — start running
+      slm adapters stop <name>         — stop running
+      slm adapters status              — detailed status
+    """
+    from superlocalmemory.ingestion.adapter_manager import handle_adapters_cli
+    # args.rest contains everything after "adapters"
+    rest = getattr(args, 'rest', []) or []
+    handle_adapters_cli(rest)
+
+
 # -- Setup & Config (no --json — interactive commands) ---------------------
 
 
@@ -1159,72 +1181,32 @@ def _warmup_diagnose() -> None:
 
 
 def cmd_dashboard(args: Namespace) -> None:
-    """Launch the web dashboard."""
-    try:
-        import uvicorn
-    except ImportError:
-        print("Dashboard requires additional deps. Run: slm doctor")
-        print("Or install manually: pip install 'fastapi[all]' uvicorn")
-        sys.exit(1)
-
-    import os
-    import signal
-    import socket
+    """Open the web dashboard in the browser.
 
-    port = getattr(args, "port", 8765)
-
-    def _kill_existing_on_port(target_port: int) -> None:
-        """Kill any existing SLM dashboard on the target port.
-
-        V3.3.2: ONE port, no auto-increment. If port is busy with
-        another SLM instance, kill it. If busy with a non-SLM process,
-        warn and exit — never silently shift to a different port.
-        """
-        if sys.platform == "win32":
-            return  # Windows: user must close manually
-        try:
-            import subprocess
-            result = subprocess.run(
-                ["lsof", "-ti", f":{target_port}"],
-                capture_output=True, text=True, timeout=5,
-            )
-            if result.returncode == 0 and result.stdout.strip():
-                pids = result.stdout.strip().split("\n")
-                for pid_str in pids:
-                    pid = int(pid_str.strip())
-                    if pid == os.getpid():
-                        continue
-                    # Check if it's an SLM/Python process
-                    ps_result = subprocess.run(
-                        ["ps", "-p", str(pid), "-o", "command="],
-                        capture_output=True, text=True, timeout=5,
-                    )
-                    cmd = ps_result.stdout.strip().lower()
-                    if "superlocalmemory" in cmd or "slm" in cmd or "uvicorn" in cmd:
-                        os.kill(pid, signal.SIGTERM)
-                        print(f"  Stopped previous dashboard (PID {pid})")
-                        import time
-                        time.sleep(1)
-        except Exception:
-            pass  # Best-effort
-
-    _kill_existing_on_port(port)
+    v3.4.3: Dashboard is now served by the unified daemon. This command
+    ensures the daemon is running and opens the browser. It does NOT
+    start a separate server (saves ~500MB RAM from duplicate engine).
+    """
+    from superlocalmemory.cli.daemon import ensure_daemon, _get_port
 
-    # Brief wait for port to fully release after killing old process
-    import time
-    time.sleep(1)
+    port = getattr(args, "port", None) or _get_port()
 
-    print("=" * 60)
     print("  SuperLocalMemory V3 — Web Dashboard")
-    print("=" * 60)
-    print(f"  Dashboard:  http://localhost:{port}")
-    print(f"  API Docs:   http://localhost:{port}/api/docs")
-    print("  Press Ctrl+C to stop\n")
+    print(f"  Starting daemon if needed...")
+
+    if not ensure_daemon():
+        print("  ✗ Could not start daemon. Run `slm doctor` to diagnose.")
+        sys.exit(1)
 
-    from superlocalmemory.server.ui import create_app
+    url = f"http://localhost:{port}"
+    print(f"  ✓ Daemon running")
+    print(f"  Dashboard: {url}")
+    print(f"  API Docs:  {url}/docs")
 
-    app = create_app()
-    uvicorn.run(app, host="127.0.0.1", port=port, log_level="info")
+    # Open browser
+    import webbrowser
+    webbrowser.open(url)
+    print("\n  Dashboard opened in browser. Daemon continues running in background.")
 
 
 # -- Profiles (supports --json) -------------------------------------------

package/src/superlocalmemory/cli/daemon.py

@@ -2,26 +2,18 @@
 # Licensed under the Elastic License 2.0 - see LICENSE file
 # Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
 
-"""SLM Daemon — keeps engine warm for instant CLI/MCP response.
+"""SLM Daemon — client functions for communicating with the unified daemon.
 
-Problem: CLI cold start is 23s (embedding worker spawn + model load).
-Solution: Background daemon keeps MemoryEngine warm. CLI commands route
-requests through the daemon via localhost HTTP (~10ms overhead).
+The unified daemon (server/unified_daemon.py) runs as a single FastAPI/uvicorn
+process on port 8765, with port 8767 as a backward-compat TCP redirect.
 
-Architecture:
-  slm serve       → starts daemon (engine init, workers warm, ~600MB RAM)
-  slm remember X  → HTTP POST to daemon → instant (no cold start)
-  slm recall X    → HTTP GET from daemon → instant
-  slm serve stop  → graceful shutdown, workers killed, RAM freed
+This module contains CLIENT functions used by CLI commands:
+  - is_daemon_running(): check if daemon is alive
+  - ensure_daemon(): start daemon if not running
+  - stop_daemon(): gracefully stop the daemon
+  - daemon_request(): send HTTP request to daemon
 
-Auto-start: if daemon not running on CLI use, starts it automatically.
-Auto-shutdown: after 30 min idle (configurable via SLM_DAEMON_IDLE_TIMEOUT).
-
-Memory safety:
-  - RSS watchdog on embedding worker (2.5GB cap)
-  - Worker recycling every 5000 requests
-  - Parent watchdog kills workers if daemon dies
-  - SQLite WAL mode for concurrent access
+The actual daemon server code is in server/unified_daemon.py.
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
 License: Elastic-2.0
@@ -42,8 +34,9 @@ from threading import Thread
 
 logger = logging.getLogger(__name__)
 
-_DEFAULT_PORT = 8767
-_DEFAULT_IDLE_TIMEOUT = 1800  # 30 min
+_DEFAULT_PORT = 8765  # v3.4.3: unified daemon on 8765 (was 8767)
+_LEGACY_PORT = 8767   # backward-compat redirect
+_DEFAULT_IDLE_TIMEOUT = 0  # v3.4.3: 24/7 default (was 1800)
 _PID_FILE = Path.home() / ".superlocalmemory" / "daemon.pid"
 _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 
@@ -53,26 +46,70 @@ _PORT_FILE = Path.home() / ".superlocalmemory" / "daemon.port"
 # ---------------------------------------------------------------------------
 
 def is_daemon_running() -> bool:
-    """Check if daemon is alive via PID file + HTTP health check."""
+    """Check if daemon is alive via PID file + HTTP health check.
+
+    v3.4.3: Checks both port 8765 (new) and 8767 (legacy) for upgrade compat.
+    Also checks ports directly if PID file is missing (daemon started by MCP/hook).
+    """
     if not _PID_FILE.exists():
+        # PID file missing but daemon might still be running (started by MCP/hook)
+        # Try health check on known ports
+        for try_port in (_DEFAULT_PORT, _LEGACY_PORT):
+            try:
+                import urllib.request
+                resp = urllib.request.urlopen(
+                    f"http://127.0.0.1:{try_port}/health", timeout=2,
+                )
+                if resp.status == 200:
+                    # Daemon is running without PID file — write one for future checks
+                    try:
+                        import json as _json
+                        data = _json.loads(resp.read().decode())
+                        pid = data.get("pid")
+                        if pid:
+                            _PID_FILE.parent.mkdir(parents=True, exist_ok=True)
+                            _PID_FILE.write_text(str(pid))
+                            _PORT_FILE.write_text(str(try_port))
+                    except Exception:
+                        pass
+                    return True
+            except Exception:
+                continue
         return False
     try:
         pid = int(_PID_FILE.read_text().strip())
-        os.kill(pid, 0)  # Check if process exists
-    except (ValueError, ProcessLookupError, PermissionError):
+        # Cross-platform PID check via psutil if available, else os.kill
+        try:
+            import psutil
+            if not psutil.pid_exists(pid):
+                _PID_FILE.unlink(missing_ok=True)
+                return False
+        except ImportError:
+            try:
+                os.kill(pid, 0)
+            except (ProcessLookupError, PermissionError):
+                _PID_FILE.unlink(missing_ok=True)
+                return False
+    except ValueError:
         _PID_FILE.unlink(missing_ok=True)
         return False
 
-    # PID exists — verify HTTP health
+    # PID exists — verify HTTP health on primary port
     port = _get_port()
-    try:
-        import urllib.request
-        resp = urllib.request.urlopen(
-            f"http://127.0.0.1:{port}/health", timeout=2,
-        )
-        return resp.status == 200
-    except Exception:
-        return False
+    for try_port in (port, _DEFAULT_PORT, _LEGACY_PORT):
+        try:
+            import urllib.request
+            resp = urllib.request.urlopen(
+                f"http://127.0.0.1:{try_port}/health", timeout=2,
+            )
+            if resp.status == 200:
+                # Update port file if it was stale (upgrade from 8767 → 8765)
+                if try_port != port:
+                    _PORT_FILE.write_text(str(try_port))
+                return True
+        except Exception:
+            continue
+    return False
 
 
 def _get_port() -> int:
@@ -100,22 +137,30 @@ def daemon_request(method: str, path: str, body: dict | None = None) -> dict | N
 
 
 def ensure_daemon() -> bool:
-    """Start daemon if not running. Returns True if daemon is ready."""
+    """Start daemon if not running. Returns True if daemon is ready.
+
+    v3.4.3: Starts unified daemon (server/unified_daemon.py) instead of
+    old stdlib daemon. Cross-platform subprocess flags.
+    """
     if is_daemon_running():
         return True
 
-    # Start daemon in background
+    # Start unified daemon in background
     import subprocess
-    cmd = [sys.executable, "-m", "superlocalmemory.cli.daemon", "--start"]
+    cmd = [sys.executable, "-m", "superlocalmemory.server.unified_daemon", "--start"]
     log_dir = Path.home() / ".superlocalmemory" / "logs"
     log_dir.mkdir(parents=True, exist_ok=True)
     log_file = log_dir / "daemon.log"
 
+    # Cross-platform background process flags
+    kwargs: dict = {}
+    if sys.platform == "win32":
+        kwargs["creationflags"] = subprocess.CREATE_NO_WINDOW
+    else:
+        kwargs["start_new_session"] = True
+
     with open(log_file, "a") as lf:
-        subprocess.Popen(
-            cmd, stdout=lf, stderr=lf,
-            start_new_session=True,
-        )
+        subprocess.Popen(cmd, stdout=lf, stderr=lf, **kwargs)
 
     # Wait for daemon to become ready (max 30s for cold start)
     for _ in range(60):
@@ -127,19 +172,34 @@ def ensure_daemon() -> bool:
 
 
 def stop_daemon() -> bool:
-    """Stop the running daemon gracefully."""
+    """Stop the running daemon gracefully.
+
+    v3.4.3: Uses psutil for cross-platform process termination.
+    Falls back to os.kill if psutil unavailable.
+    """
     if not _PID_FILE.exists():
         return True
     try:
         pid = int(_PID_FILE.read_text().strip())
-        os.kill(pid, signal.SIGTERM)
-        # Wait for cleanup
-        for _ in range(20):
-            time.sleep(0.5)
-            try:
-                os.kill(pid, 0)
-            except ProcessLookupError:
-                break
+
+        # Cross-platform termination via psutil
+        try:
+            import psutil
+            proc = psutil.Process(pid)
+            proc.terminate()  # SIGTERM on Unix, TerminateProcess on Windows
+            proc.wait(timeout=10)
+        except ImportError:
+            # Fallback: direct signal (works on Unix, may fail on Windows)
+            os.kill(pid, signal.SIGTERM)
+            for _ in range(20):
+                time.sleep(0.5)
+                try:
+                    os.kill(pid, 0)
+                except ProcessLookupError:
+                    break
+        except Exception:
+            pass
+
         _PID_FILE.unlink(missing_ok=True)
         _PORT_FILE.unlink(missing_ok=True)
         return True

package/src/superlocalmemory/cli/main.py

@@ -272,6 +272,16 @@ def main() -> None:
     )
     reap_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
+    # V3.4.3: Ingestion adapters
+    adapters_p = sub.add_parser(
+        "adapters",
+        help="Manage ingestion adapters (Gmail, Calendar, Transcript)",
+    )
+    adapters_p.add_argument(
+        "rest", nargs="*", default=[],
+        help="Subcommand: list, enable, disable, start, stop, status [name]",
+    )
+
     args = parser.parse_args()
 
     if not args.command: