superlocalmemory 4.1.13 → 4.1.14

package/src/superlocalmemory/hooks/auto_recall.py

@@ -1,191 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""Auto-recall — inject relevant memories into AI context automatically."""
-
-from __future__ import annotations
-
-import logging
-from typing import Any, Callable
-
-from superlocalmemory.core.injection import InjectableMemory, render_context
-from superlocalmemory.retrieval.temporal_frame import relative_age, temporal_frame
-
-logger = logging.getLogger(__name__)
-
-
-class AutoRecall:
-    """Automatically recalls relevant context for AI sessions.
-
-    Called at session start or before each prompt to inject
-    relevant memories without user intervention.
-
-    Two ways to wire the recall side:
-
-    - Pass ``engine=<MemoryEngine>`` (CLI/daemon path — historical shape).
-    - Pass ``recall_fn=<callable>`` (MCP/LIGHT path — the callable adapts
-      a worker-pool call to the ``RecallResponse``-shaped return value).
-      When both are supplied, ``recall_fn`` wins.
-    """
-
-    def __init__(
-        self,
-        engine=None,
-        config: dict | None = None,
-        *,
-        recall_fn: Callable[..., Any] | None = None,
-    ):
-        self._engine = engine
-        self._recall_fn = recall_fn
-        self._config = config or {}
-        self._enabled = self._config.get("enabled", True)
-        self._max_memories = self._config.get("max_memories_injected", 10)
-        self._threshold = self._config.get("relevance_threshold", 0.3)
-
-    def _get_soft_prompt_text(self) -> str:
-        """Return soft prompt text via engine._auto_invoker (V3.3 bridge, fail-soft).
-
-        The CLI and daemon paths pass ``engine=<MemoryEngine>`` to AutoRecall.
-        The engine stores an AutoInvoker that has a wired PromptInjector.
-        This bridge lets AutoRecall surface soft prompts without needing the
-        caller to pass a separate PromptInjector argument.
-
-        Falls back to "" when no engine, no invoker, or any error occurs.
-        """
-        try:
-            invoker = getattr(self._engine, "_auto_invoker", None)
-            if invoker is None:
-                return ""
-            getter = getattr(invoker, "_get_soft_prompt_text", None)
-            if getter is None:
-                return ""
-            return getter() or ""
-        except Exception as exc:
-            # warning: unexpected bridge failure silences a claimed feature
-            logger.warning("Soft-prompt bridge (AutoRecall→AutoInvoker) failed: %s", exc)
-            return ""
-
-    def _recall(self, query: str, limit: int):
-        if self._recall_fn is not None:
-            return self._recall_fn(query, limit=limit)
-        if self._engine is not None:
-            return self._engine.recall(query, limit=limit)
-        return None
-
-    def get_session_context(self, project_path: str = "", query: str = "") -> str:
-        """Get relevant context for a session or query.
-
-        Returns a formatted string of relevant memories suitable
-        for injection into an AI's system prompt.
-
-        Soft prompts are fetched via the engine→AutoInvoker bridge FIRST so
-        they are returned even when recall finds no memories.  Memory recall
-        is then layered on top when results are present.
-        """
-        if not self._enabled:
-            return ""
-        if self._recall_fn is None and self._engine is None:
-            return ""
-
-        # --- 1. Soft-prompt (fail-soft, may return "") ---
-        soft_prompt = self._get_soft_prompt_text()
-
-        # --- 2. Memory recall ---
-        try:
-            search_query = query or f"project context {project_path}"
-            response = self._recall(search_query, self._max_memories)
-        except Exception as exc:
-            logger.warning("Auto-recall failed: %s", exc)
-            # Still return soft prompt if present
-            return soft_prompt
-
-        # --- 3. Build memory context block (empty string when no results) ---
-        memory_ctx = ""
-        try:
-            if response is not None and response.results:
-                relevant = [r for r in response.results if r.score >= self._threshold]
-                if relevant:
-                    memories = [
-                        InjectableMemory(
-                            content=r.fact.content,
-                            score=float(r.score),
-                            fact_id=str(r.fact.fact_id),
-                            importance=float(getattr(r.fact, "importance", 0.0) or 0.0),
-                            access_count=int(getattr(r.fact, "access_count", 0) or 0),
-                            source_type="recall",
-                        )
-                        for r in relevant[:self._max_memories]
-                    ]
-                    ctx = render_context(memories, mode="B", cfg=None, wrap=True)
-                    # T-inject: anchor memories to "now" so a time-blind model
-                    # can weigh recency. Prepend a one-line temporal frame.
-                    frame = temporal_frame(
-                        [getattr(r.fact, "created_at", "") for r in relevant[:self._max_memories]]
-                    )
-                    memory_ctx = f"{frame}\n\n{ctx}" if ctx else ctx
-        except Exception as exc:
-            logger.warning("Auto-recall memory formatting failed: %s", exc)
-
-        # --- 4. Combine: soft-prompt + memories (either may be empty) ---
-        parts = [p for p in (soft_prompt, memory_ctx) if p]
-        return "\n\n".join(parts)
-
-    def get_query_context(self, query: str) -> list[dict]:
-        """Get relevant memories for a specific query.
-
-        Returns structured data (not formatted string) for MCP tools.
-        """
-        if not self._enabled:
-            return []
-        if self._recall_fn is None and self._engine is None:
-            return []
-
-        try:
-            response = self._recall(query, self._max_memories)
-            if response is None:
-                return []
-            from datetime import datetime as _dt, timezone as _tz
-            _now = _dt.now(_tz.utc)
-            results = []
-            for r in response.results:
-                if r.score >= self._threshold:
-                    _created = getattr(r.fact, "created_at", "") or ""
-                    results.append({
-                        "fact_id": r.fact.fact_id,
-                        "content": r.fact.content[:300],
-                        "created_at": _created,
-                        "age_label": relative_age(_created, _now),
-                        "score": round(r.score, 3),
-                        "relevance_score": round(
-                            getattr(r, "relevance_score", r.score) or 0.0, 3
-                        ),
-                        "ranking_score": getattr(r, "ranking_score", None),
-                        "confidence": round(
-                            getattr(
-                                r, "memory_confidence",
-                                getattr(r, "confidence", 0.0),
-                            ) or 0.0, 3
-                        ),
-                        "memory_confidence": round(
-                            getattr(
-                                r, "memory_confidence",
-                                getattr(r, "confidence", 0.0),
-                            ) or 0.0, 3
-                        ),
-                        "rank_position": int(getattr(r, "rank_position", 0) or 0),
-                    })
-            return results
-        except Exception as exc:
-            logger.warning("Auto-recall query failed: %s", exc)
-            return []
-
-    @property
-    def enabled(self) -> bool:
-        return self._enabled
-
-    def enable(self) -> None:
-        self._enabled = True
-
-    def disable(self) -> None:
-        self._enabled = False

package/src/superlocalmemory/hooks/auto_recall_hook.py

@@ -1,251 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
-
-"""UserPromptSubmit hook — production auto-recall via recall_queue.
-
-Entry point for Claude Code's UserPromptSubmit event. Invoked as:
-  python3 -m superlocalmemory.hooks.auto_recall_hook
-  OR: slm hook auto_recall
-
-Flow:
-  1. Read stdin JSON (Claude Code payload)
-  2. Detect ack prompts → silent (exit 0, empty JSON)
-  3. Substantive → enqueue to recall_queue.db → poll for result
-  4. Format top-K memories as additionalContext
-  5. Write Claude Code envelope to stdout
-
-HARD RULES:
-  - stdlib-only imports at module load. SLM modules delayed-imported.
-  - NEVER imports MemoryEngine (memory blast risk).
-  - NEVER raises to Claude Code — always exits 0.
-  - Fail-open: any failure → {} to stdout.
-
-MEMORY SAFETY: recall goes through recall_queue.db → QueueConsumer
-(daemon background thread) → pool.recall() → recall_worker subprocess.
-Engine is ONLY in the recall_worker. This process stays at ~20MB.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import sys
-
-_DEFAULT_LIMIT = 15           # raised from 3 for formatter candidate pool
-
-_MODE_TIMEOUTS = {
-    "A": 10.0,
-    "B": 25.0,
-    "C": 40.0,
-}
-
-_ACK_RE = re.compile(
-    r"^\s*"
-    r"(?:yes|no|ok|okay|approved|thanks|thank you|go|sure|yep|nope|"
-    r"done|y|n|cool|got it|right|correct)"
-    r"(?:\s+(?:yes|no|ok|okay|approved|thanks|done|\d+))*"
-    r"\s*[.!?]?\s*$",
-    re.IGNORECASE,
-)
-
-
-def _is_ack(prompt: str) -> bool:
-    return len(prompt) <= 30 and bool(_ACK_RE.match(prompt))
-
-
-def _get_mode_timeout(mode: str) -> float:
-    return _MODE_TIMEOUTS.get(mode.upper(), _MODE_TIMEOUTS["B"])
-
-
-def _detect_mode() -> str:
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        config = SLMConfig.load()
-        return getattr(config, "mode", "B").upper()
-    except Exception:
-        return "B"
-
-
-def _get_queue_db_path():
-    from superlocalmemory.infra.data_root import state_path
-
-    return state_path("recall_queue.db")
-
-
-def _try_socket_first(prompt: str, session_id: str) -> dict | None:
-    """Try the persistent hook daemon socket. Returns full envelope or None.
-
-    The socket path returns an already-formatted Claude Code envelope.
-    If this returns a non-None dict, the caller writes it to stdout directly
-    (skip _do_recall + _format_envelope). Returns None on any failure,
-    triggering the subprocess fallback.
-    """
-    try:
-        from superlocalmemory.hooks.hook_daemon import try_socket_recall
-        response = try_socket_recall(
-            prompt=prompt,
-            session_id=session_id,
-            timeout=_get_mode_timeout(_detect_mode()),
-        )
-        if response is None or not isinstance(response, dict):
-            return None
-        if not response:
-            return {}
-        return response
-    except Exception:
-        return None
-
-
-def _do_recall(query: str, limit: int = _DEFAULT_LIMIT, session_id: str = "") -> list[dict] | None:
-    """Enqueue recall to queue, poll for result. Returns list of dicts or None."""
-    try:
-        from superlocalmemory.core.recall_queue import RecallQueue
-
-        mode = _detect_mode()
-        timeout = _get_mode_timeout(mode)
-        stall_timeout = max(timeout - 5.0, 5.0)
-        db_path = _get_queue_db_path()
-        queue = RecallQueue(db_path)
-
-        try:
-            request_id = queue.enqueue(
-                query=query,
-                limit_n=limit,
-                mode=mode,
-                agent_id="auto_recall_hook",
-                session_id=session_id,
-                priority="high",
-                stall_timeout_s=stall_timeout,
-            )
-
-            result = queue.poll_result(request_id, timeout_s=timeout)
-
-            if isinstance(result, dict):
-                if result.get("ok") is False:
-                    return None
-                results = result.get("results", [])
-                if isinstance(results, list):
-                    return results
-            return None
-        finally:
-            queue.close()
-
-    except Exception:
-        return _fallback_recall(query, limit, session_id)
-
-
-def _fallback_recall(query: str, limit: int, session_id: str) -> list[dict] | None:
-    """Fallback: call daemon HTTP /recall if queue path fails."""
-    try:
-        import urllib.parse
-        import urllib.request
-
-        params = urllib.parse.urlencode({"q": query, "limit": limit})
-        url = f"http://127.0.0.1:47152/recall?{params}"
-
-        req = urllib.request.Request(url, method="GET")
-        req.add_header("X-SLM-Session-Id", session_id)
-
-        with urllib.request.urlopen(req, timeout=5.0) as resp:
-            data = json.loads(resp.read().decode("utf-8"))
-            return data.get("results", [])
-    except Exception:
-        return None
-
-
-def _format_envelope(results: list[dict]) -> dict:
-    """Format recall results as Claude Code envelope. Uses shared formatter
-    (v3.4.65). Fail closed if the mandatory renderer is unavailable."""
-    try:
-        from superlocalmemory.core.config import SLMConfig
-        from superlocalmemory.core.injection import InjectableMemory, render_context
-        cfg = SLMConfig.load().injection
-        mode = _detect_mode()
-        inj = [
-            InjectableMemory(
-                content=str(r.get("content", "")),
-                score=float(r.get("score", 0) or 0),
-                fact_id=str(r.get("fact_id", "")),
-                importance=float(r.get("importance", 0) or 0),
-                access_count=int(r.get("access_count", 0) or 0),
-                source_type=str(r.get("source_type", "recall")),
-                source_id=str(r.get("source_id", "auto-recall-hook")),
-            )
-            for r in results
-        ]
-        wrapped = render_context(inj, mode=mode, cfg=cfg, wrap=True)
-        return {
-            "hookSpecificOutput": {
-                "hookEventName": "UserPromptSubmit",
-                "additionalContext": wrapped,
-            }
-        }
-    except Exception:
-        # A weaker ad-hoc formatter would create a second security contract and
-        # could leak unredacted stored text. No memory is safer than unbounded,
-        # unredacted memory when the mandatory renderer fails.
-        return {}
-
-
-def main() -> int:
-    try:
-        raw = sys.stdin.read()
-    except Exception:
-        sys.stdout.write("{}")
-        return 0
-
-    if not raw or not raw.strip():
-        sys.stdout.write("{}")
-        return 0
-
-    try:
-        payload = json.loads(raw)
-    except Exception:
-        sys.stdout.write("{}")
-        return 0
-
-    if not isinstance(payload, dict):
-        sys.stdout.write("{}")
-        return 0
-
-    prompt = payload.get("prompt", "")
-    session_id = payload.get("session_id", "")
-
-    if not isinstance(prompt, str) or not prompt.strip():
-        sys.stdout.write("{}")
-        return 0
-
-    if _is_ack(prompt):
-        sys.stdout.write("{}")
-        return 0
-
-    try:
-        socket_result = _try_socket_first(prompt, session_id)
-        if socket_result is not None:
-            sys.stdout.write(json.dumps(socket_result) if socket_result else "{}")
-            return 0
-    except Exception:
-        pass
-
-    try:
-        results = _do_recall(prompt, limit=_DEFAULT_LIMIT, session_id=session_id)
-    except Exception:
-        sys.stdout.write("{}")
-        return 0
-
-    if not results:
-        sys.stdout.write("{}")
-        return 0
-
-    try:
-        envelope = _format_envelope(results)
-        sys.stdout.write(json.dumps(envelope))
-    except Exception:
-        sys.stdout.write("{}")
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/src/superlocalmemory/hooks/before_web_hook.py

@@ -1,131 +0,0 @@
-# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
-# Licensed under AGPL-3.0-or-later - see LICENSE file
-# Part of SuperLocalMemory v3.4.43 — Pre-web recall on WebSearch/WebFetch
-
-"""Pre-web recall hook — fires SLM recall before any WebSearch/WebFetch call.
-
-Dispatch: `slm hook before_web` (PreToolUse, matcher "WebSearch|WebFetch").
-
-WHY THIS HOOK EXISTS
-====================
-End users typically have hundreds-to-thousands of relevant memories in their
-local SLM. When Claude is about to issue a WebSearch or WebFetch, there's a
-high chance the answer (or strong constraints on the answer) is already in
-SLM. This hook forces a recall pass on the search query/URL and injects the
-top hits as a system-reminder BEFORE the web call fires. Claude must consider
-the local memories before committing to the external call.
-
-PERFORMANCE
-===========
-Cost: ~500-800ms warm (full recall via SLM daemon). Fires only on
-WebSearch and WebFetch (5-20× per typical session), so per-session overhead
-is ~5-15s in exchange for grounded answers. NOT suitable for UserPromptSubmit
-(too frequent — would be a perf disaster).
-
-CONTRACT
-========
-- Reads Claude Code stdin: {"tool_input": {"query"|"url"|"prompt": "..."}}
-- On non-trivial query: calls `slm recall <query> --limit 5`, injects top
-  results as a system-reminder block.
-- On empty/short query / recall failure / SLM down: silent exit 0.
-- Always exit 0 — never blocks the web call.
-"""
-
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-from typing import Any
-
-_MIN_QUERY_LEN = 5
-_QUERY_TRUNCATE = 200
-_RECALL_LIMIT = 5
-_RECALL_TIMEOUT_SEC = 3
-_RECALLED_MAX_CHARS = 3000
-_RECALLED_MIN_USEFUL = 50
-_PREVIEW_CHARS = 80
-
-_SHIM_PREFIX = "[SLM PRE-WEB RECALL"
-
-
-def _extract_query(payload: dict[str, Any]) -> str:
-    """Pull the search query / URL / prompt from Claude Code stdin payload."""
-    ti = payload.get("tool_input") or {}
-    if not isinstance(ti, dict):
-        return ""
-    raw = ti.get("query") or ti.get("prompt") or ti.get("url") or ""
-    if not isinstance(raw, str):
-        return ""
-    return raw[:_QUERY_TRUNCATE].strip()
-
-
-def _read_input() -> dict[str, Any]:
-    """Parse stdin JSON. Returns empty dict on any failure."""
-    try:
-        raw = sys.stdin.read()
-        if not raw:
-            return {}
-        data = json.loads(raw)
-        if isinstance(data, dict):
-            return data
-        return {}
-    except (json.JSONDecodeError, ValueError, OSError):
-        return {}
-
-
-def _run_recall(query: str) -> str:
-    """Run `slm recall <query> --limit N`. Returns trimmed output or empty."""
-    try:
-        # Bounded query length (already truncated to 200 chars). Subprocess
-        # timeout caps daemon-down risk at 3s.
-        proc = subprocess.run(
-            ["slm", "recall", query, "--limit", str(_RECALL_LIMIT)],
-            capture_output=True,
-            text=True,
-            timeout=_RECALL_TIMEOUT_SEC,
-        )
-        if proc.returncode != 0:
-            return ""
-        out = (proc.stdout or "")[:_RECALLED_MAX_CHARS]
-        if len(out) < _RECALLED_MIN_USEFUL:
-            return ""
-        return out
-    except (subprocess.TimeoutExpired, OSError, ValueError):
-        return ""
-
-
-def main() -> int:
-    """Entry point. Always returns 0 — fail-open contract."""
-    try:
-        payload = _read_input()
-        query = _extract_query(payload)
-        if len(query) < _MIN_QUERY_LEN:
-            return 0
-
-        recalled = _run_recall(query)
-        if not recalled:
-            return 0
-
-        preview = query[:_PREVIEW_CHARS].replace('"', "'")
-        from superlocalmemory.core.injection import render_untrusted_text
-        memory_evidence = render_untrusted_text(
-            recalled,
-            source_type="before-web-recall",
-            source_id=preview,
-        )
-        if not memory_evidence:
-            return 0
-        sys.stdout.write(
-            "<system-reminder>\n"
-            f'{_SHIM_PREFIX} — fired before WebSearch/WebFetch on query: "{preview}"]\n'
-            "You're about to search the web. SLM already has these relevant memories.\n"
-            "READ THEM FIRST. If they answer the question, skip the web call. If they\n"
-            "contradict what you'd find on the web, surface the contradiction. Do not\n"
-            "ignore them.\n\n"
-            f"{memory_evidence}\n"
-            "</system-reminder>\n"
-        )
-    except Exception:  # noqa: BLE001 — fail-open contract
-        pass
-    return 0