loki-mode 6.82.0 → 6.83.0

package/memory/managed_memory/fakes.py

@@ -0,0 +1,120 @@
+"""
+Loki Managed Agents Memory - FakeManagedClient for CI tests (v6.83.0 Phase 1).
+
+Implements the same surface as ManagedClient but keeps state in memory and
+returns deterministic responses keyed on input path. Used by
+tests/managed_memory/test_*_mock.py so CI does not call the real API.
+
+This file is importable without the `anthropic` SDK installed.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from typing import Any, Dict, List, Optional
+
+
+class _Conflict(Exception):
+    """Simulated 409 raised by memory_create on sha256 mismatch."""
+
+    status_code = 409
+
+
+class FakeManagedClient:
+    """In-memory fake matching ManagedClient's public interface."""
+
+    def __init__(self) -> None:
+        self.stores: Dict[str, Dict[str, Any]] = {}
+        # memories keyed by (store_id, path) -> dict(content, sha, version)
+        self.memories: Dict[tuple, Dict[str, Any]] = {}
+        self.calls: List[Dict[str, Any]] = []
+
+    # ---------- stores --------------------------------------------------
+
+    def stores_list(self) -> List[Dict[str, Any]]:
+        self.calls.append({"op": "stores_list"})
+        return list(self.stores.values())
+
+    def stores_get_or_create(
+        self, name: str, description: str = "", scope: str = "project"
+    ) -> Dict[str, Any]:
+        self.calls.append({"op": "stores_get_or_create", "name": name})
+        for s in self.stores.values():
+            if s.get("name") == name:
+                return s
+        store_id = f"store_{len(self.stores) + 1:04d}"
+        store = {
+            "id": store_id,
+            "name": name,
+            "description": description,
+            "scope": scope,
+        }
+        self.stores[store_id] = store
+        return store
+
+    # ---------- memories ------------------------------------------------
+
+    def memory_create(
+        self,
+        store_id: str,
+        path: str,
+        content: str,
+        sha256_precondition: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        self.calls.append(
+            {
+                "op": "memory_create",
+                "store_id": store_id,
+                "path": path,
+                "sha256_precondition": sha256_precondition,
+            }
+        )
+        key = (store_id, path)
+        sha = hashlib.sha256(content.encode("utf-8")).hexdigest()
+        existing = self.memories.get(key)
+        if existing is not None and sha256_precondition is not None:
+            if existing["sha"] != sha256_precondition:
+                # Simulated 409: caller must re-read + merge + retry.
+                raise _Conflict(
+                    f"sha256 mismatch for {path}: "
+                    f"have={existing['sha']}, want={sha256_precondition}"
+                )
+        version = (existing.get("version", 0) + 1) if existing else 1
+        entry = {
+            "id": f"mem_{abs(hash(key)) % 10**8:08d}",
+            "store_id": store_id,
+            "path": path,
+            "content": content,
+            "sha": sha,
+            "version": version,
+        }
+        self.memories[key] = entry
+        return entry
+
+    def memory_read(self, store_id: str, memory_id: str) -> Dict[str, Any]:
+        self.calls.append({"op": "memory_read", "memory_id": memory_id})
+        for entry in self.memories.values():
+            if entry.get("id") == memory_id:
+                return entry
+        raise KeyError(memory_id)
+
+    def memories_list(
+        self, store_id: str, path_prefix: Optional[str] = None
+    ) -> List[Dict[str, Any]]:
+        self.calls.append(
+            {"op": "memories_list", "store_id": store_id, "path_prefix": path_prefix}
+        )
+        out = []
+        for (sid, path), entry in self.memories.items():
+            if sid != store_id:
+                continue
+            if path_prefix and not path.startswith(path_prefix):
+                continue
+            out.append(entry)
+        return out
+
+
+# Helper exported for tests that need to simulate the 409 without
+# importing the private _Conflict class directly.
+def make_conflict_error() -> Exception:
+    return _Conflict("forced conflict for tests")

package/memory/managed_memory/retrieve.py

@@ -0,0 +1,347 @@
+"""
+Loki Managed Agents Memory - Retrieve path (v6.83.0 Phase 1).
+
+Used by the REASON phase (retrieve_memory_context in autonomy/run.sh) and by
+the completion council (augment prompts with prior verdicts). Also provides
+hydrate_patterns() which pulls semantic patterns updated after a local mtime
+floor and merges them into .loki/memory/semantic/patterns.json via the
+existing MemoryStorage._atomic_write.
+
+CLI:
+    python3 -m memory.managed_memory.retrieve --query <str> [--top-k N] \\
+        [--store-id <id>]
+
+    python3 -m memory.managed_memory.retrieve --hydrate [--since-seconds N]
+
+Never raises: on any error the CLI prints nothing and exits 0. Bash callers
+apply a 5s hard timeout; this module keeps its own 10s SDK timeout.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from . import ManagedDisabled, is_enabled
+from .events import emit_managed_event
+
+_LOG = logging.getLogger("loki.managed_memory.retrieve")
+
+_DEFAULT_STORE_NAME = "loki-rarv-c-learnings"
+
+
+def _store_name() -> str:
+    return os.environ.get("LOKI_MANAGED_STORE_NAME", _DEFAULT_STORE_NAME)
+
+
+def _warn_once(msg: str) -> None:
+    sys.stderr.write(f"WARN [managed_memory] {msg}\n")
+
+
+def _get_client():
+    from .client import get_client
+
+    return get_client()
+
+
+def _summarize(content: str, limit: int = 240) -> str:
+    """Return a short single-line summary for prompt injection."""
+    s = (content or "").strip().replace("\n", " ")
+    if len(s) > limit:
+        s = s[: limit - 3] + "..."
+    return s
+
+
+# ---------------------------------------------------------------------------
+# Retrieve related verdicts (used by REASON and completion council)
+# ---------------------------------------------------------------------------
+
+
+def retrieve_related_verdicts(
+    query: str,
+    top_k: int = 3,
+    store_id: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Return up to `top_k` recent verdicts most-related to `query`.
+
+    Phase 1 implementation: fetch memories under `verdicts/` and
+    prefix-match. This is naive but honest -- true similarity retrieval
+    ships in Phase 2 when the beta exposes a semantic search endpoint.
+    Returns [] on any error.
+    """
+    if not is_enabled():
+        return []
+
+    start = time.monotonic()
+    try:
+        client = _get_client()
+    except ManagedDisabled as e:
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "client_unavailable", "detail": str(e), "op": "retrieve"},
+        )
+        return []
+    except Exception as e:  # pragma: no cover - defensive
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "client_error", "detail": str(e), "op": "retrieve"},
+        )
+        return []
+
+    try:
+        if not store_id:
+            store = client.stores_get_or_create(
+                name=_store_name(),
+                description="Loki Mode RARV-C shadow-write store (v6.83.0)",
+                scope="project",
+            )
+            store_id = store.get("id") or store.get("store_id")
+        if not store_id:
+            return []
+        entries = client.memories_list(store_id=store_id, path_prefix="verdicts/")
+    except Exception as e:
+        _warn_once(f"memories_list failed ({e}); returning empty")
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "list_error", "detail": str(e), "op": "retrieve"},
+        )
+        return []
+
+    # Naive ranking: keep entries whose content contains any query token.
+    tokens = [t.lower() for t in query.split() if len(t) > 2]
+    scored: List[tuple] = []
+    for e in entries:
+        content = e.get("content") or ""
+        content_lc = content.lower()
+        score = sum(1 for t in tokens if t in content_lc)
+        scored.append((score, e))
+    scored.sort(key=lambda pair: pair[0], reverse=True)
+
+    out: List[Dict[str, Any]] = []
+    for score, e in scored[:top_k]:
+        out.append(
+            {
+                "path": e.get("path"),
+                "content_summary": _summarize(e.get("content") or ""),
+                "version_id": e.get("version") or e.get("version_id"),
+                "score": score,
+            }
+        )
+
+    emit_managed_event(
+        "managed_memory_retrieve",
+        {
+            "query_tokens": len(tokens),
+            "hits": len(out),
+            "total_candidates": len(entries),
+            "elapsed_ms": int((time.monotonic() - start) * 1000),
+        },
+    )
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Hydrate semantic patterns
+# ---------------------------------------------------------------------------
+
+
+def hydrate_patterns(
+    local_mtime_floor: float,
+    target_dir: Optional[str] = None,
+) -> int:
+    """
+    Pull semantic patterns from the managed store and merge them into
+    .loki/memory/semantic/patterns.json. Returns the number of patterns
+    merged in. Returns 0 on disabled / error.
+
+    Only patterns whose remote version timestamp is newer than
+    `local_mtime_floor` are merged. The merge is additive: existing local
+    patterns with the same pattern_id are kept unchanged.
+    """
+    if not is_enabled():
+        return 0
+
+    try:
+        client = _get_client()
+    except ManagedDisabled as e:
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "client_unavailable", "detail": str(e), "op": "hydrate"},
+        )
+        return 0
+    except Exception as e:  # pragma: no cover
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "client_error", "detail": str(e), "op": "hydrate"},
+        )
+        return 0
+
+    try:
+        store = client.stores_get_or_create(
+            name=_store_name(),
+            description="Loki Mode RARV-C shadow-write store (v6.83.0)",
+            scope="project",
+        )
+        store_id = store.get("id") or store.get("store_id")
+        if not store_id:
+            return 0
+        entries = client.memories_list(store_id=store_id, path_prefix="patterns/")
+    except Exception as e:
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "list_error", "detail": str(e), "op": "hydrate"},
+        )
+        return 0
+
+    target_dir = target_dir or os.environ.get("LOKI_TARGET_DIR") or os.getcwd()
+    patterns_path = Path(target_dir) / ".loki" / "memory" / "semantic" / "patterns.json"
+
+    # Read existing local patterns file (may not exist).
+    existing: Dict[str, Any] = {"patterns": {}}
+    if patterns_path.exists():
+        try:
+            with open(patterns_path, "r", encoding="utf-8") as f:
+                existing = json.load(f)
+        except (OSError, json.JSONDecodeError):
+            existing = {"patterns": {}}
+    if "patterns" not in existing or not isinstance(existing["patterns"], dict):
+        existing["patterns"] = {}
+
+    merged = 0
+    for e in entries:
+        content = e.get("content")
+        if not content:
+            continue
+        try:
+            pat = json.loads(content)
+        except (TypeError, json.JSONDecodeError):
+            continue
+        pid = pat.get("pattern_id") or pat.get("id")
+        if not pid:
+            continue
+        if pid in existing["patterns"]:
+            # Local wins on duplicate ids (Phase 1 policy).
+            continue
+        # Optional mtime gate: skip if the remote entry has a timestamp and
+        # it predates the floor.
+        ts = pat.get("updated_at") or pat.get("created_at")
+        if ts and local_mtime_floor:
+            try:
+                # Very loose timestamp parse: accept both epoch and ISO.
+                if isinstance(ts, (int, float)) and float(ts) < local_mtime_floor:
+                    continue
+            except (TypeError, ValueError):
+                pass
+        existing["patterns"][pid] = pat
+        merged += 1
+
+    if merged == 0:
+        emit_managed_event(
+            "managed_memory_hydrate", {"merged": 0, "candidates": len(entries)}
+        )
+        return 0
+
+    # Use existing MemoryStorage._atomic_write where possible; fall back to
+    # tempfile+rename if MemoryStorage is not importable in this process.
+    try:
+        # Late import to avoid module-load cycles.
+        from memory.storage import MemoryStorage  # type: ignore
+
+        storage = MemoryStorage(str(patterns_path.parent.parent))
+        storage._atomic_write(patterns_path, existing)
+    except Exception:
+        # Fallback: inline atomic write.
+        import tempfile
+
+        patterns_path.parent.mkdir(parents=True, exist_ok=True)
+        fd, tmp = tempfile.mkstemp(
+            dir=str(patterns_path.parent), prefix=".tmp_", suffix=".json"
+        )
+        try:
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(existing, f, indent=2, default=str)
+            os.replace(tmp, patterns_path)
+        except Exception as e:
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+            emit_managed_event(
+                "managed_agents_fallback",
+                {"reason": "atomic_write_failed", "detail": str(e), "op": "hydrate"},
+            )
+            return 0
+
+    emit_managed_event(
+        "managed_memory_hydrate",
+        {"merged": merged, "candidates": len(entries)},
+    )
+    return merged
+
+
+# ---------------------------------------------------------------------------
+# Module CLI
+# ---------------------------------------------------------------------------
+
+
+def _main(argv: Optional[list] = None) -> int:
+    # Silent no-op if flags are off; bash callers rely on exit 0 + empty stdout.
+    if not is_enabled():
+        return 0
+
+    parser = argparse.ArgumentParser(
+        prog="python3 -m memory.managed_memory.retrieve",
+        description="Retrieve related verdicts / hydrate patterns from the managed store.",
+    )
+    parser.add_argument("--query", help="Retrieval query string")
+    parser.add_argument("--top-k", type=int, default=3)
+    parser.add_argument("--store-id", default=None)
+    parser.add_argument(
+        "--hydrate",
+        action="store_true",
+        help="Hydrate semantic patterns into .loki/memory/semantic/",
+    )
+    parser.add_argument(
+        "--since-seconds",
+        type=int,
+        default=0,
+        help="Hydrate: only merge patterns newer than NOW - since_seconds",
+    )
+    args = parser.parse_args(argv)
+
+    try:
+        if args.hydrate:
+            floor = 0.0
+            if args.since_seconds and args.since_seconds > 0:
+                floor = time.time() - args.since_seconds
+            hydrate_patterns(local_mtime_floor=floor)
+            return 0
+
+        query = args.query or ""
+        if not query:
+            return 0
+        results = retrieve_related_verdicts(
+            query=query, top_k=args.top_k, store_id=args.store_id
+        )
+        # Print one line per hit, suitable for pasting into a prompt section.
+        for r in results:
+            path = r.get("path", "")
+            summary = r.get("content_summary", "")
+            print(f"- [managed] {path}: {summary}")
+        return 0
+    except Exception as e:  # pragma: no cover - defensive
+        _warn_once(f"retrieve CLI unexpected error: {e}")
+        emit_managed_event(
+            "managed_agents_fallback",
+            {"reason": "cli_unexpected", "detail": str(e), "op": "retrieve"},
+        )
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_main())