superlocalmemory 3.4.18 → 3.4.21

package/src/superlocalmemory/cli/commands.py

@@ -12,10 +12,55 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import os
 import sys
 from argparse import Namespace
 
 
+def _cmd_db_dispatch(args: Namespace) -> None:
+    """Route ``slm db ...`` subcommands. LLD-06 §7.2."""
+    sub = getattr(args, "db_command", None)
+    if sub == "migrate":
+        from superlocalmemory.cli.db_migrate import cmd_db_migrate
+        rc = cmd_db_migrate(args)
+        if rc:
+            sys.exit(rc)
+        return
+    print("Usage: slm db migrate [--status] [--dry-run]")
+    sys.exit(2)
+
+
+def _cmd_escape_disable(args: Namespace) -> None:
+    from superlocalmemory.cli.escape_hatch import cmd_disable
+    cmd_disable(args)
+
+
+def _cmd_escape_enable(args: Namespace) -> None:
+    from superlocalmemory.cli.escape_hatch import cmd_enable
+    cmd_enable(args)
+
+
+def _cmd_escape_clear_cache(args: Namespace) -> None:
+    from superlocalmemory.cli.escape_hatch import cmd_clear_cache
+    cmd_clear_cache(args)
+
+
+def _cmd_escape_reconfigure(args: Namespace) -> None:
+    from superlocalmemory.cli.escape_hatch import cmd_reconfigure
+    cmd_reconfigure(args)
+
+
+def _cmd_escape_benchmark(args: Namespace) -> None:
+    from superlocalmemory.cli.escape_hatch import cmd_benchmark
+    cmd_benchmark(args)
+
+
+def _cmd_escape_rotate_token(args: Namespace) -> None:
+    """S-M07: rotate the install token."""
+    from superlocalmemory.cli.escape_hatch import cmd_rotate_token
+    cmd_rotate_token(args)
+
+
 def dispatch(args: Namespace) -> None:
     """Route CLI command to the appropriate handler."""
     # Auto-install/upgrade hooks on version change (single file read, ~0.1ms)
@@ -67,6 +112,17 @@ def dispatch(args: Namespace) -> None:
         # V3.4.11 skill evolution
         "config": cmd_config,
         "evolve": cmd_evolve,
+        # V3.4.21 LLD-05 context pre-staging
+        "context": _cmd_context_dispatch,
+        # V3.4.21 LLD-06 additive schema migrations
+        "db": _cmd_db_dispatch,
+        # V3.4.21 Stage 8 SB-5 — MASTER-PLAN §8 escape hatches.
+        "disable": _cmd_escape_disable,
+        "enable": _cmd_escape_enable,
+        "clear-cache": _cmd_escape_clear_cache,
+        "reconfigure": _cmd_escape_reconfigure,
+        "benchmark": _cmd_escape_benchmark,
+        "rotate-token": _cmd_escape_rotate_token,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -633,8 +689,21 @@ def cmd_provider(args: Namespace) -> None:
             print(f"Model: {config.llm.model}")
 
 
+def _cmd_context_dispatch(args: Namespace) -> None:
+    """V3.4.21 LLD-05: ``slm context prestage``."""
+    from superlocalmemory.cli.context_commands import cmd_context
+    cmd_context(args)
+
+
 def cmd_connect(args: Namespace) -> None:
-    """Configure IDE integrations."""
+    """Configure IDE integrations. V3.4.21: ``--cross-platform`` uses LLD-05."""
+    # Route --disable <name> and --cross-platform to the LLD-05 orchestrator.
+    if getattr(args, "disable", None) or getattr(args, "cross_platform", False):
+        from superlocalmemory.cli.context_commands import (
+            cmd_connect_cross_platform,
+        )
+        cmd_connect_cross_platform(args)
+        return
     from superlocalmemory.hooks.ide_connector import IDEConnector
 
     connector = IDEConnector()
@@ -824,12 +893,19 @@ def cmd_recall(args: Namespace) -> None:
 
     # V3.3.21: Route through daemon for instant response (no cold start).
     # Falls back to direct engine if daemon not running.
+    # S9-DASH-02: pass a stable session_id derived from the shell's
+    # parent PID so a sequence of CLI recalls in one terminal can be
+    # grouped. The Stop hook on session end won't fire for CLI, so
+    # these outcomes are closed by the reaper (TTL → neutral reward).
     try:
         from superlocalmemory.cli.daemon import is_daemon_running, daemon_request, ensure_daemon
         if is_daemon_running() or ensure_daemon():
             from urllib.parse import quote
+            session_id = f"cli:{os.getppid()}"
             result = daemon_request(
-                "GET", f"/recall?q={quote(args.query)}&limit={args.limit}",
+                "GET",
+                f"/recall?q={quote(args.query)}&limit={args.limit}"
+                f"&session_id={quote(session_id)}",
             )
             if result and "results" in result:
                 # Format daemon response same as engine response
@@ -1156,6 +1232,30 @@ def cmd_status(args: Namespace) -> None:
         size_mb = round(config.db_path.stat().st_size / 1024 / 1024, 2)
         print(f"  DB size: {size_mb} MB")
 
+    # S9-UX-07 / S9-UX-13: --verbose surfaces the disabled marker,
+    # last-version marker, and daemon port so users who are debugging
+    # "slm seems broken" get the signal without opening three files.
+    if getattr(args, "verbose", False):
+        home = config.base_dir
+        disabled_path = home / ".disabled"
+        version_path = home / ".last_version"
+        print()
+        print("  --verbose --")
+        print(
+            f"  Disabled marker: "
+            f"{'YES (slm enable to reactivate)' if disabled_path.exists() else 'no'}",
+        )
+        if version_path.exists():
+            try:
+                last_ver = version_path.read_text(encoding="utf-8").strip()
+            except OSError:
+                last_ver = "(unreadable)"
+            print(f"  Last booted version: {last_ver}")
+        else:
+            print("  Last booted version: (never booted)")
+        port = os.environ.get("SLM_DAEMON_PORT") or "8765"
+        print(f"  Daemon port: {port}")
+
 
 def cmd_health(args: Namespace) -> None:
     """Show math layer health status."""
@@ -1198,11 +1298,18 @@ def cmd_health(args: Namespace) -> None:
 
 
 def cmd_doctor(args: Namespace) -> None:
-    """Comprehensive pre-flight check — verify everything works."""
+    """Comprehensive pre-flight check — verify everything works.
+
+    S9-UX-10: ``--quick`` skips the slow probes (embedding worker
+    subprocess, Ollama roundtrip) so first-run installer hooks can
+    surface a sub-second PASS/FAIL line before letting the user go.
+    Full doctor remains the default for ``slm doctor`` with no flag.
+    """
     import shutil
     from pathlib import Path
 
     use_json = getattr(args, "json", False)
+    quick = getattr(args, "quick", False)
     checks: list[dict] = []
     passed = warned = failed = 0
 
@@ -1315,86 +1422,119 @@ def cmd_doctor(args: Namespace) -> None:
         _check("Performance deps", "WARN", f"Missing: {', '.join(missing)}",
                "pip install diskcache orjson")
 
-    # 7. Embedding worker functional test
-    try:
-        import subprocess as _sp
-        import json as _json
-
-        env = {
-            **__import__("os").environ,
-            "CUDA_VISIBLE_DEVICES": "",
-            "PYTORCH_MPS_HIGH_WATERMARK_RATIO": "0.0",
-            "TOKENIZERS_PARALLELISM": "false",
-            "TORCH_DEVICE": "cpu",
-        }
-        proc = _sp.Popen(
-            [sys.executable, "-m", "superlocalmemory.core.embedding_worker"],
-            stdin=_sp.PIPE, stdout=_sp.PIPE, stderr=_sp.DEVNULL,
-            text=True, bufsize=1, env=env,
-        )
-        proc.stdin.write(_json.dumps({"cmd": "ping"}) + "\n")
-        proc.stdin.flush()
-
-        import select as _sel
-        ready, _, _ = _sel.select([proc.stdout], [], [], 30)
-        if ready:
-            resp = _json.loads(proc.stdout.readline())
-            if resp.get("ok"):
-                _check("Embedding worker", "PASS",
-                       f"responsive (PID {proc.pid}, Python {sys.executable})")
+    # 7. Embedding worker functional test — skipped under --quick.
+    if quick:
+        _check("Embedding worker", "PASS", "skipped (--quick)")
+    else:
+        try:
+            import subprocess as _sp
+            import json as _json
+
+            env = {
+                **__import__("os").environ,
+                "CUDA_VISIBLE_DEVICES": "",
+                "PYTORCH_MPS_HIGH_WATERMARK_RATIO": "0.0",
+                "TOKENIZERS_PARALLELISM": "false",
+                "TORCH_DEVICE": "cpu",
+            }
+            proc = _sp.Popen(
+                [sys.executable, "-m",
+                 "superlocalmemory.core.embedding_worker"],
+                stdin=_sp.PIPE, stdout=_sp.PIPE, stderr=_sp.DEVNULL,
+                text=True, bufsize=1, env=env,
+            )
+            proc.stdin.write(_json.dumps({"cmd": "ping"}) + "\n")
+            proc.stdin.flush()
+
+            import select as _sel
+            ready, _, _ = _sel.select([proc.stdout], [], [], 30)
+            if ready:
+                resp = _json.loads(proc.stdout.readline())
+                if resp.get("ok"):
+                    _check(
+                        "Embedding worker", "PASS",
+                        f"responsive (PID {proc.pid}, "
+                        f"Python {sys.executable})",
+                    )
+                else:
+                    _check(
+                        "Embedding worker", "FAIL",
+                        f"error: {resp.get('error', 'unknown')}",
+                        "pip install sentence-transformers einops torch",
+                    )
             else:
-                _check("Embedding worker", "FAIL",
-                       f"error: {resp.get('error', 'unknown')}",
-                       "pip install sentence-transformers einops torch")
-        else:
-            _check("Embedding worker", "FAIL", "timed out (30s)",
-                   "slm warmup")
-        proc.stdin.write(_json.dumps({"cmd": "quit"}) + "\n")
-        proc.stdin.flush()
-        proc.wait(timeout=5)
-    except FileNotFoundError:
-        _check("Embedding worker", "FAIL", "embedding_worker module not found",
-               "Reinstall: npm install -g superlocalmemory")
-    except Exception as exc:
-        _check("Embedding worker", "FAIL", str(exc),
-               "slm warmup")
+                _check("Embedding worker", "FAIL", "timed out (30s)",
+                       "slm warmup")
+            proc.stdin.write(_json.dumps({"cmd": "quit"}) + "\n")
+            proc.stdin.flush()
+            proc.wait(timeout=5)
+        except FileNotFoundError:
+            _check(
+                "Embedding worker", "FAIL",
+                "embedding_worker module not found",
+                "Reinstall: npm install -g superlocalmemory",
+            )
+        except Exception as exc:
+            _check("Embedding worker", "FAIL", str(exc), "slm warmup")
 
-    # 8. Ollama connectivity (Mode B only)
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        config = SLMConfig.load()
-        if config.mode.value == "b":
-            import httpx
-            try:
-                resp = httpx.get(
-                    f"{config.llm.api_base}/api/tags", timeout=5.0,
-                )
-                if resp.status_code == 200:
-                    models = [m["name"].split(":")[0] for m in resp.json().get("models", [])]
-                    has_llm = config.llm.model.split(":")[0] in models
-                    if has_llm:
-                        _check("Ollama", "PASS",
-                               f"running, {len(models)} models, '{config.llm.model}' available")
+    # 8. Ollama connectivity (Mode B only) — skipped under --quick.
+    if quick:
+        _check("Ollama / API key", "PASS", "skipped (--quick)")
+    else:
+        try:
+            from superlocalmemory.core.config import SLMConfig
+            config = SLMConfig.load()
+            if config.mode.value == "b":
+                import httpx
+                try:
+                    resp = httpx.get(
+                        f"{config.llm.api_base}/api/tags", timeout=5.0,
+                    )
+                    if resp.status_code == 200:
+                        models = [
+                            m["name"].split(":")[0]
+                            for m in resp.json().get("models", [])
+                        ]
+                        has_llm = config.llm.model.split(":")[0] in models
+                        if has_llm:
+                            _check(
+                                "Ollama", "PASS",
+                                f"running, {len(models)} models, "
+                                f"'{config.llm.model}' available",
+                            )
+                        else:
+                            _check(
+                                "Ollama", "WARN",
+                                f"running but '{config.llm.model}' "
+                                f"not pulled",
+                                f"ollama pull {config.llm.model}",
+                            )
                     else:
-                        _check("Ollama", "WARN",
-                               f"running but '{config.llm.model}' not pulled",
-                               f"ollama pull {config.llm.model}")
+                        _check(
+                            "Ollama", "WARN",
+                            f"HTTP {resp.status_code}",
+                            "brew services start ollama",
+                        )
+                except Exception:
+                    _check(
+                        "Ollama", "WARN",
+                        "not reachable at " + config.llm.api_base,
+                        "brew services start ollama",
+                    )
+            elif config.mode.value == "c":
+                if config.llm.api_key:
+                    _check(
+                        "API key", "PASS",
+                        f"provider={config.llm.provider}, "
+                        f"key=***{config.llm.api_key[-4:]}",
+                    )
                 else:
-                    _check("Ollama", "WARN", f"HTTP {resp.status_code}",
-                           "brew services start ollama")
-            except Exception:
-                _check("Ollama", "WARN", "not reachable at " + config.llm.api_base,
-                       "brew services start ollama")
-        elif config.mode.value == "c":
-            # Mode C — check API key
-            if config.llm.api_key:
-                _check("API key", "PASS",
-                       f"provider={config.llm.provider}, key=***{config.llm.api_key[-4:]}")
-            else:
-                _check("API key", "WARN", "no API key configured",
-                       "slm provider set")
-    except Exception:
-        pass  # Config load failed — already caught above
+                    _check(
+                        "API key", "WARN", "no API key configured",
+                        "slm provider set",
+                    )
+        except Exception:
+            pass  # Config load failed — already caught above
 
     # 9. Disk space
     slm_home = Path.home() / ".superlocalmemory"

package/src/superlocalmemory/cli/context_commands.py

@@ -0,0 +1,192 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory v3.4.21 — LLD-05 §8
+
+"""CLI — ``slm context prestage`` and ``slm connect --disable`` (LLD-05).
+
+Kept in a focused module (instead of bloating cli/commands.py past its cap).
+"""
+
+from __future__ import annotations
+
+import json as _json
+import os
+from argparse import Namespace
+from pathlib import Path
+from typing import Callable
+
+from superlocalmemory.hooks.antigravity_adapter import AntigravityAdapter
+from superlocalmemory.hooks.copilot_adapter import CopilotAdapter
+from superlocalmemory.hooks.cursor_adapter import CursorAdapter
+from superlocalmemory.hooks.context_payload import (
+    RecallFn,
+    build_payload,
+    format_decisions,
+    format_entities,
+    format_memories,
+    format_topics,
+)
+from superlocalmemory.hooks.cross_platform_connector import (
+    CrossPlatformConnector,
+)
+from superlocalmemory.mcp.tools_context import prestage_context
+
+
+def _noop_recall(_q: str, _limit: int, _profile: str) -> list[dict]:
+    """Placeholder recall when the daemon/engine isn't reachable."""
+    return []
+
+
+def _get_recall_fn() -> RecallFn:
+    """Wire the real recall engine if available, else no-op."""
+    try:
+        from superlocalmemory.core.engine import Engine  # pragma: no cover
+        eng = Engine.get_shared()
+        def _fn(q: str, limit: int, profile_id: str) -> list[dict]:
+            try:
+                return eng.recall(q, limit=limit) or []  # type: ignore
+            except Exception:
+                return []
+        return _fn
+    except Exception:
+        return _noop_recall
+
+
+def _default_sync_log_db() -> Path:
+    return Path(os.environ.get("SLM_MEMORY_DB",
+                               str(Path.home() / ".superlocalmemory"
+                                   / "memory.db")))
+
+
+def build_default_adapters(
+    *, base_dir: Path | None = None,
+    recall_fn: RecallFn | None = None,
+    sync_log_db: Path | None = None,
+) -> list:
+    base = Path(base_dir or Path.cwd())
+    recall = recall_fn or _get_recall_fn()
+    db = sync_log_db or _default_sync_log_db()
+    adapters: list = []
+    adapters.append(CursorAdapter(scope="project", base_dir=base,
+                                  sync_log_db=db, recall_fn=recall))
+    adapters.append(CursorAdapter(scope="global", base_dir=Path.home(),
+                                  sync_log_db=db, recall_fn=recall))
+    adapters.append(AntigravityAdapter(scope="workspace", base_dir=base,
+                                       sync_log_db=db, recall_fn=recall))
+    adapters.append(AntigravityAdapter(scope="global", base_dir=Path.home(),
+                                       sync_log_db=db, recall_fn=recall))
+    adapters.append(CopilotAdapter(base_dir=base, sync_log_db=db,
+                                   recall_fn=recall))
+    return adapters
+
+
+# ---------------------------------------------------------------------------
+# `slm connect` (LLD-05 mode)
+# ---------------------------------------------------------------------------
+
+
+def cmd_connect_cross_platform(args: Namespace) -> None:
+    """LLD-05 mode: orchestrate cross-platform adapters."""
+    adapters = build_default_adapters()
+    connector = CrossPlatformConnector(adapters)
+
+    disable_target = getattr(args, "disable", None)
+    if disable_target:
+        ok = connector.disable(disable_target)
+        msg = {"adapter": disable_target, "disabled": ok}
+        if getattr(args, "json", False):
+            print(_json.dumps(msg))
+        else:
+            print(f"{'Disabled' if ok else 'Not found'}: {disable_target}")
+        return
+
+    if getattr(args, "dry_run", False):
+        statuses = connector.detect()
+        out = [
+            {"name": s.name, "active": s.active, "target": s.target_path}
+            for s in statuses
+        ]
+        if getattr(args, "json", False):
+            print(_json.dumps({"detected": out}))
+        else:
+            for row in out:
+                mark = "[+]" if row["active"] else "[-]"
+                print(f"  {mark} {row['name']:25s} {row['target']}")
+        return
+
+    results = connector.connect()
+    if getattr(args, "json", False):
+        print(_json.dumps({"results": results}))
+    else:
+        for name, res in results.items():
+            print(f"  {name}: {res}")
+
+
+# ---------------------------------------------------------------------------
+# `slm context prestage`
+# ---------------------------------------------------------------------------
+
+
+def _render_markdown(payload) -> str:
+    lines = [
+        "# --- SLM Context ---",
+        f"_Version {payload.version} — {payload.generated_at}_",
+        "",
+        "## Topics",
+        format_topics(payload),
+        "",
+        "## Entities",
+        format_entities(payload),
+        "",
+        "## Recent decisions",
+        format_decisions(payload),
+        "",
+        "## Project memories",
+        format_memories(payload),
+    ]
+    return "\n".join(lines)
+
+
+def cmd_context(args: Namespace) -> None:
+    """Dispatcher for ``slm context <subcommand>``."""
+    sub = getattr(args, "subcommand", None) or "prestage"
+    if sub != "prestage":
+        print(f"Unknown subcommand: {sub}")
+        return
+
+    query = getattr(args, "query", "") or ""
+    limit = int(getattr(args, "limit", 5))
+    profile_id = getattr(args, "profile_id", "default")
+
+    if getattr(args, "tool", False):
+        # Direct MCP-like tool response.
+        result = prestage_context(
+            query, limit=limit, profile_id=profile_id,
+            recall_fn=_get_recall_fn(),
+        )
+        print(_json.dumps(result, indent=2))
+        return
+
+    # Build a full markdown / JSON payload for CLI consumption.
+    payload = build_payload(
+        profile_id, "project", Path.cwd(),
+        recall_fn=_get_recall_fn(),
+    )
+    if getattr(args, "json", False):
+        print(_json.dumps({
+            "query": query,
+            "topics": list(payload.topics),
+            "entities": list(payload.entities),
+            "decisions": list(payload.recent_decisions),
+            "memories": list(payload.project_memories),
+            "generated_at": payload.generated_at,
+        }))
+        return
+    print(_render_markdown(payload))
+
+
+__all__ = (
+    "build_default_adapters",
+    "cmd_context",
+    "cmd_connect_cross_platform",
+)

package/src/superlocalmemory/cli/daemon.py

@@ -473,8 +473,22 @@ class DaemonHandler(BaseHTTPRequestHandler):
                 query = params.get("q", [""])[0]
                 limit = int(params.get("limit", ["20"])[0])
 
+                # S9-DASH-02: session_id for outcome-queue enqueue.
+                # Priority: ?session_id= query arg > X-SLM-Session-Id
+                # header > synthetic "cli:<ts>". Without any of these
+                # the recall still works — it just doesn't produce a
+                # pending_outcome (hook-based signals can't match).
+                session_id = params.get("session_id", [""])[0]
+                if not session_id:
+                    session_id = self.headers.get("X-SLM-Session-Id", "")
+                if not session_id:
+                    import time as _t
+                    session_id = f"http:{int(_t.time() * 1000)}"
+
                 engine = _get_engine()
-                response = engine.recall(query, limit=limit)
+                response = engine.recall(
+                    query, limit=limit, session_id=session_id,
+                )
                 results = [
                     {"content": r.fact.content, "score": round(r.score, 4),
                      "fact_type": getattr(r.fact.fact_type, 'value', str(r.fact.fact_type)),

package/src/superlocalmemory/cli/db_migrate.py

@@ -0,0 +1,80 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory v3.4.21 — LLD-06 §7.2
+
+"""CLI handler for ``slm db migrate``.
+
+LLD reference: ``.backup/active-brain/lld/LLD-06-windows-binary-and-legacy-migration.md``
+Section 7.2 (slm db migrate CLI).
+
+Thin wrapper over the canonical runner in
+``superlocalmemory.storage.migration_runner``. This module owns only
+the user-facing surface (stdout formatting + exit codes). All DDL +
+runner logic lives in LLD-07 territory — per H15, no migration schema
+is defined or duplicated here.
+"""
+from __future__ import annotations
+
+from argparse import Namespace
+from pathlib import Path
+
+
+# Canonical paths — match LLD-01 / LLD-07 layout. Callers can override
+# via the ``learning_db_path`` / ``memory_db_path`` attributes on args
+# (tests rely on this to point at fixture DBs).
+DEFAULT_HOME = Path.home() / ".superlocalmemory"
+
+
+def _resolve_paths(args: Namespace) -> tuple[Path, Path]:
+    learning = getattr(args, "learning_db_path", None)
+    memory = getattr(args, "memory_db_path", None)
+    if learning is None:
+        learning = DEFAULT_HOME / "learning.db"
+    if memory is None:
+        memory = DEFAULT_HOME / "memory.db"
+    return Path(learning), Path(memory)
+
+
+def cmd_db_migrate(args: Namespace) -> int:
+    """Apply pending migrations or report status.
+
+    Behaviour:
+      - ``--status`` prints the per-migration status recorded in each
+        DB's ``migration_log``. Exit 0 unless reading fails.
+      - ``--dry-run`` runs the runner in dry-run mode (no writes).
+      - Default: runs ``apply_all``.
+
+    Exit codes (also returned for tests that capture return value):
+      - 0 on success (no failed migrations).
+      - 1 if any migration is reported as ``failed``.
+    """
+    from superlocalmemory.storage.migration_runner import apply_all, status
+
+    learning_db, memory_db = _resolve_paths(args)
+
+    if getattr(args, "status", False):
+        report = status(learning_db, memory_db)
+        if not report:
+            print("(no migrations registered)")
+        else:
+            for name, state in report.items():
+                print(f"  {name}: {state}")
+        return 0
+
+    dry_run = bool(getattr(args, "dry_run", False))
+    result = apply_all(learning_db, memory_db, dry_run=dry_run)
+    applied = result.get("applied", [])
+    skipped = result.get("skipped", [])
+    failed = result.get("failed", [])
+    print(
+        f"Applied={len(applied)} Skipped={len(skipped)} Failed={len(failed)}"
+    )
+    if failed:
+        details = result.get("details", {})
+        for name in failed:
+            print(f"  FAILED {name}: {details.get(name, '(no detail)')}")
+        return 1
+    return 0
+
+
+__all__ = ("cmd_db_migrate", "DEFAULT_HOME")