memorymaster 3.5.1__tar.gz → 3.5.2__tar.gz

{memorymaster-3.5.1/memorymaster.egg-info → memorymaster-3.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.5.1
+Version: 3.5.2
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.5.1 → memorymaster-3.5.2}/memorymaster/config_templates/hooks/memorymaster-steward-cycle.py

@@ -6,6 +6,19 @@ DB_PATH = os.path.join(PROJECT_ROOT, "memorymaster.db")
 
 sys.path.insert(0, PROJECT_ROOT)
 os.environ["MEMORYMASTER_DEFAULT_DB"] = DB_PATH
+
+# LLM stack: claude_cli (Claude Code OAuth via local `claude --print`) is the
+# primary, with Ollama gemma4:e4b as a defensive fallback. Direct assignment
+# (NOT setdefault) — the hook MUST own these vars so an inherited shell env
+# can't silently route LLM calls to a stale provider. Bug observed 2026-04-25:
+# setdefault was a no-op when the inherited env already had MEMORYMASTER_LLM_PROVIDER
+# set, so the new model name routed to the OLD provider → 50× HTTP 404 per cycle
+# before the fallback chain saved it. Captured as v3.5.0 release notes.
+os.environ["MEMORYMASTER_LLM_PROVIDER"] = "claude_cli"
+os.environ["MEMORYMASTER_LLM_MODEL"] = "claude-haiku-4-5-20251001"
+os.environ["MEMORYMASTER_LLM_FALLBACK_PROVIDER"] = "ollama"
+os.environ["MEMORYMASTER_LLM_FALLBACK_MODEL"] = "gemma4:e4b"
+
 os.chdir(PROJECT_ROOT)
 
 try:
@@ -36,11 +49,9 @@ try:
 except Exception as e:
     print(f"[MemoryMaster] auto-archive error: {e}", file=sys.stderr)
 
-# Wiki absorb (compiled truth + timeline articles)
+# Wiki absorb (compiled truth + timeline articles). Inherits the LLM provider
+# block above — uses the same OAuth-backed haiku stack as the steward.
 try:
-    # Keys come from the rotator file (~/.memorymaster/gemini-keys.env) or a
-    # singular GEMINI_API_KEY env var. Hook must never hardcode credentials.
-    os.environ.setdefault("MEMORYMASTER_LLM_PROVIDER", "google")
     from memorymaster.wiki_engine import absorb
     wiki_path = os.path.join(PROJECT_ROOT, "obsidian-vault", "wiki")
     stats = absorb(DB_PATH, wiki_path)

{memorymaster-3.5.1 → memorymaster-3.5.2/memorymaster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.5.1
+Version: 3.5.2
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.5.1 → memorymaster-3.5.2}/memorymaster.egg-info/SOURCES.txt

@@ -189,6 +189,7 @@ scripts/generate_drill_signoff.py
 scripts/git_to_turns.py
 scripts/github_live_to_turns.py
 scripts/gitnexus_to_claims.py
+scripts/grid_recall_weights.py
 scripts/index_claims_to_qdrant.py
 scripts/ingest_planning_docs.py
 scripts/jira_live_to_turns.py
@@ -251,12 +252,14 @@ tests/test_fts5_search.py
 tests/test_graph_distance.py
 tests/test_graph_store.py
 tests/test_handler_regressions.py
+tests/test_hook_env_isolation.py
 tests/test_human_id.py
 tests/test_incident_drill_runner.py
 tests/test_integration_workflows.py
 tests/test_key_rotator.py
 tests/test_lifecycle.py
 tests/test_llm_fallback.py
+tests/test_llm_provider_claude_cli.py
 tests/test_llm_steward_coverage.py
 tests/test_llm_steward_key_rotation.py
 tests/test_mcp_helpers.py

{memorymaster-3.5.1 → memorymaster-3.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.5.1"
+version = "3.5.2"
 description = "Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration."
 license = {text = "MIT"}
 authors = [{name = "wolverin0"}]

memorymaster-3.5.2/scripts/grid_recall_weights.py

@@ -0,0 +1,191 @@
+"""Grid-search the recall weight knobs against precision@5.
+
+Sweeps W_LEXICAL × W_FRESHNESS × W_GRAPH against the existing 100-prompt
+evaluation harness (`scripts/eval_recall_precision_at_5.py`) and writes a
+sorted markdown table + raw JSONL log so a future tweak is reproducible.
+
+W_VECTOR is skipped because the local DB has no Qdrant; the stream is a
+no-op without `MEMORYMASTER_USE_QDRANT=1` and a populated index.
+
+Usage:
+    python scripts/grid_recall_weights.py \
+        --prompts artifacts/real-prompts-100.jsonl \
+        --db memorymaster.db \
+        --output artifacts/recall-weight-tuning-2026-04-26.md
+"""
+from __future__ import annotations
+
+import argparse
+import itertools
+import json
+import os
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# Modest 3 × 3 × 4 = 36 grid. Bounded by ~10s/combo wall via subprocess startup.
+W_LEXICAL_GRID = (0.2, 0.3, 0.4)
+W_FRESHNESS_GRID = (0.0, 0.05, 0.1)
+W_GRAPH_GRID = (0.0, 0.05, 0.1, 0.2)
+
+METRIC_RE = {
+    "precision@5": re.compile(r"precision@5\s*=\s*([\d.]+)"),
+    "MAP@5": re.compile(r"MAP@5\s*=\s*([\d.]+)"),
+    "hit@5": re.compile(r"hit@5\s*=\s*([\d.]+)"),
+    "p95_ms": re.compile(r"p95\s*=\s*([\d.]+)\s*ms"),
+}
+
+
+def _run_eval(
+    eval_script: Path,
+    prompts: Path,
+    db: Path,
+    weights: dict,
+    json_out: Path,
+    label: str,
+) -> dict | None:
+    env = os.environ.copy()
+    for k, v in weights.items():
+        env[f"MEMORYMASTER_RECALL_{k}"] = str(v)
+    # The GRAPH stream is opt-in: W_GRAPH alone is a no-op unless the stream
+    # itself is enabled. Turn it on only when the weight is non-zero — keeps
+    # the latency-cost cells out of the grid when they can't possibly help.
+    if weights.get("W_GRAPH", 0) > 0:
+        env["MEMORYMASTER_RECALL_GRAPH"] = "1"
+    # Same for the freshness stream.
+    if weights.get("W_FRESHNESS", 0) > 0:
+        env["MEMORYMASTER_RECALL_FRESHNESS"] = "1"
+
+    proc = subprocess.run(
+        [
+            sys.executable,
+            str(eval_script),
+            "--prompts",
+            str(prompts),
+            "--db",
+            str(db),
+            "--json-out",
+            str(json_out),
+            "--label",
+            label,
+        ],
+        capture_output=True,
+        text=True,
+        env=env,
+        timeout=600,
+    )
+    if proc.returncode != 0:
+        return {"error": proc.stderr.strip()[:200] or "non-zero exit"}
+
+    out = proc.stdout
+    parsed = {"label": label, **{k: v for k, v in weights.items()}}
+    for metric, rgx in METRIC_RE.items():
+        m = rgx.search(out)
+        parsed[metric] = float(m.group(1)) if m else None
+    return parsed
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("--prompts", type=Path, required=True)
+    p.add_argument("--db", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument(
+        "--eval-script",
+        type=Path,
+        default=Path("scripts/eval_recall_precision_at_5.py"),
+    )
+    p.add_argument(
+        "--per-run-json-dir",
+        type=Path,
+        default=Path("artifacts/grid-runs"),
+        help="Per-cell raw eval JSONL dump directory.",
+    )
+    args = p.parse_args()
+
+    args.per_run_json_dir.mkdir(parents=True, exist_ok=True)
+
+    combos = list(
+        itertools.product(W_LEXICAL_GRID, W_FRESHNESS_GRID, W_GRAPH_GRID)
+    )
+    print(f"[grid] running {len(combos)} cells over W_LEXICAL × W_FRESHNESS × W_GRAPH")
+
+    rows: list[dict] = []
+    t_total = time.monotonic()
+    for i, (w_lex, w_fresh, w_graph) in enumerate(combos, 1):
+        weights = {"W_LEXICAL": w_lex, "W_FRESHNESS": w_fresh, "W_GRAPH": w_graph}
+        label = f"L{w_lex}_F{w_fresh}_G{w_graph}"
+        json_out = args.per_run_json_dir / f"{label}.jsonl"
+        t0 = time.monotonic()
+        row = _run_eval(args.eval_script, args.prompts, args.db, weights, json_out, label)
+        wall = time.monotonic() - t0
+        if row is None:
+            row = {"error": "no output"}
+        row["wall_s"] = round(wall, 1)
+        rows.append(row)
+        prec = row.get("precision@5")
+        prec_str = f"{prec:.3f}" if isinstance(prec, float) else "ERR"
+        print(f"[grid] {i}/{len(combos)} {label} wall={wall:.1f}s p@5={prec_str}")
+
+    # Pick best by precision@5 (tie-break MAP@5 desc, then p95 asc)
+    valid = [r for r in rows if isinstance(r.get("precision@5"), float)]
+    valid.sort(
+        key=lambda r: (
+            -r["precision@5"],
+            -(r.get("MAP@5") or 0.0),
+            r.get("p95_ms") or 1e9,
+        )
+    )
+
+    # Write markdown report
+    lines = [
+        "# Recall weight grid — precision@5 tuning",
+        "",
+        f"- Eval prompts: `{args.prompts}` (100, 70 labeled)",
+        f"- DB: `{args.db}` (post-L2-backfill snapshot)",
+        f"- Grid: W_LEXICAL × W_FRESHNESS × W_GRAPH = "
+        f"{len(W_LEXICAL_GRID)} × {len(W_FRESHNESS_GRID)} × {len(W_GRAPH_GRID)} = {len(combos)} cells",
+        f"- Total wall: {round(time.monotonic()-t_total, 1)}s",
+        "",
+        "## Top 10 by precision@5",
+        "",
+        "| W_LEXICAL | W_FRESHNESS | W_GRAPH | precision@5 | MAP@5 | hit@5 | p95 ms | wall s |",
+        "|---|---|---|---|---|---|---|---|",
+    ]
+    for r in valid[:10]:
+        lines.append(
+            f"| {r['W_LEXICAL']} | {r['W_FRESHNESS']} | {r['W_GRAPH']} "
+            f"| {r['precision@5']:.3f} | {r.get('MAP@5'):.3f} | {r.get('hit@5'):.3f} "
+            f"| {r.get('p95_ms')} | {r['wall_s']} |"
+        )
+    if not valid:
+        lines.append("| — | — | — | NO VALID RUNS | | | | |")
+    else:
+        winner = valid[0]
+        lines += [
+            "",
+            "## Winner",
+            "",
+            f"`MEMORYMASTER_RECALL_W_LEXICAL={winner['W_LEXICAL']}` "
+            f"`MEMORYMASTER_RECALL_W_FRESHNESS={winner['W_FRESHNESS']}` "
+            f"`MEMORYMASTER_RECALL_W_GRAPH={winner['W_GRAPH']}`",
+            "",
+            f"precision@5 = **{winner['precision@5']:.3f}** "
+            f"(baseline 0.152, delta = {(winner['precision@5'] - 0.152):+.3f})",
+        ]
+
+    args.output.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    # Also dump rows as JSON for downstream automation
+    json_path = args.output.with_suffix(".json")
+    json_path.write_text(json.dumps(rows, indent=2), encoding="utf-8")
+
+    print(f"[grid] wrote {args.output}")
+    print(f"[grid] wrote {json_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

memorymaster-3.5.2/tests/test_hook_env_isolation.py

@@ -0,0 +1,79 @@
+"""Regression tests for the steward-cycle hook env wiring (v3.5.0 fix).
+
+Bug: the deployed hook used `os.environ.setdefault("MEMORYMASTER_LLM_PROVIDER", ...)`,
+which is a no-op when the inherited shell env already has the var set. After
+switching the primary to claude_cli, an inherited `MEMORYMASTER_LLM_PROVIDER=google`
+left the provider unchanged — but `MEMORYMASTER_LLM_MODEL` was set to the new
+Claude model name, producing 50× HTTP 404 from the Gemini API per cycle before
+the fallback chain saved it.
+
+Fix: hook MUST use direct `os.environ["KEY"] = ...` assignment.
+
+These tests assert against the SHIPPED template
+(`memorymaster/config_templates/hooks/memorymaster-steward-cycle.py`) so a
+reverted edit fails CI before the broken hook reaches a user via
+`memorymaster-setup`.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+TEMPLATE = (
+    Path(__file__).resolve().parents[1]
+    / "memorymaster"
+    / "config_templates"
+    / "hooks"
+    / "memorymaster-steward-cycle.py"
+)
+
+
+@pytest.fixture(scope="module")
+def template_text() -> str:
+    assert TEMPLATE.exists(), f"steward hook template missing: {TEMPLATE}"
+    return TEMPLATE.read_text(encoding="utf-8")
+
+
+def test_template_does_not_use_setdefault_for_llm_provider(template_text: str) -> None:
+    """If this fails, someone reverted the v3.5.0 hook env-assignment fix."""
+    assert (
+        'setdefault("MEMORYMASTER_LLM_PROVIDER"' not in template_text
+    ), "steward hook must use os.environ['KEY'] = ... assignment, not setdefault"
+
+
+def test_template_does_not_use_setdefault_for_llm_model(template_text: str) -> None:
+    assert (
+        'setdefault("MEMORYMASTER_LLM_MODEL"' not in template_text
+    ), "steward hook must use os.environ['KEY'] = ... assignment, not setdefault"
+
+
+@pytest.mark.parametrize(
+    "key,expected_value",
+    [
+        ("MEMORYMASTER_LLM_PROVIDER", "claude_cli"),
+        ("MEMORYMASTER_LLM_MODEL", "claude-haiku-4-5-20251001"),
+        ("MEMORYMASTER_LLM_FALLBACK_PROVIDER", "ollama"),
+        ("MEMORYMASTER_LLM_FALLBACK_MODEL", "gemma4:e4b"),
+    ],
+)
+def test_template_assigns_env_directly(
+    template_text: str, key: str, expected_value: str
+) -> None:
+    """Each LLM env var must be set via direct assignment with the v3.5.0 default."""
+    needle = f'os.environ["{key}"] = "{expected_value}"'
+    assert (
+        needle in template_text
+    ), f"expected `{needle}` in template; either the assignment or value drifted"
+
+
+def test_template_imports_only_from_stdlib_and_memorymaster(template_text: str) -> None:
+    """The hook is invoked from cron/Task Scheduler; it can only depend on
+    stdlib + the installed memorymaster package. A new third-party import here
+    would silently break user installs that didn't pip install the dep."""
+    forbidden = ("requests", "httpx", "aiohttp", "boto3")
+    for pkg in forbidden:
+        assert (
+            f"import {pkg}" not in template_text
+            and f"from {pkg}" not in template_text
+        ), f"steward hook must not import {pkg} (would break installs missing the dep)"

memorymaster-3.5.2/tests/test_llm_provider_claude_cli.py

@@ -0,0 +1,186 @@
+"""Tests for the claude_cli LLM provider (memorymaster.llm_provider._call_claude_cli).
+
+The provider shells out to the local `claude --print` binary. These tests mock
+subprocess.run so they don't actually invoke the CLI — they cover the defensive
+branches that the production user is most likely to hit:
+
+  - missing binary on PATH
+  - non-zero exit
+  - timeout
+  - UTF-8 round-trip including emoji
+  - MEMORYMASTER_CLAUDE_CLI_BIN override
+  - MEMORYMASTER_CLAUDE_CLI_TIMEOUT override
+  - aliases ("claude_cli", "claude-cli") resolve to the same provider
+"""
+from __future__ import annotations
+
+import subprocess
+from unittest.mock import patch
+
+import pytest
+
+from memorymaster import llm_provider
+
+
+def _completed(stdout: str = "", stderr: str = "", returncode: int = 0):
+    return subprocess.CompletedProcess(
+        args=["claude", "--print", "--model", "x"],
+        returncode=returncode,
+        stdout=stdout,
+        stderr=stderr,
+    )
+
+
+@pytest.fixture(autouse=True)
+def _clean_env(monkeypatch):
+    """Strip any inherited claude_cli env vars so each test starts clean."""
+    for key in (
+        "MEMORYMASTER_CLAUDE_CLI_BIN",
+        "MEMORYMASTER_CLAUDE_CLI_TIMEOUT",
+        "MEMORYMASTER_LLM_MODEL",
+    ):
+        monkeypatch.delenv(key, raising=False)
+
+
+def test_missing_binary_returns_empty(monkeypatch, caplog):
+    """When `claude` is not on PATH and no override is set, return '' and warn."""
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: None)
+    with caplog.at_level("WARNING"):
+        out = llm_provider._call_claude_cli("prompt", "text")
+    assert out == ""
+    assert any("binary not found" in rec.message for rec in caplog.records)
+
+
+def test_non_zero_exit_returns_empty(monkeypatch, caplog):
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+    fake_run = lambda *a, **kw: _completed(stdout="", stderr="boom", returncode=2)
+    monkeypatch.setattr(llm_provider.subprocess, "run", fake_run)
+    with caplog.at_level("WARNING"):
+        out = llm_provider._call_claude_cli("prompt", "text")
+    assert out == ""
+    assert any("exit=2" in rec.message for rec in caplog.records)
+
+
+def test_timeout_returns_empty(monkeypatch, caplog):
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+
+    def _raise(*_a, **_kw):
+        raise subprocess.TimeoutExpired(cmd="claude", timeout=120)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _raise)
+    with caplog.at_level("WARNING"):
+        out = llm_provider._call_claude_cli("prompt", "text")
+    assert out == ""
+    assert any("timed out" in rec.message for rec in caplog.records)
+
+
+def test_oserror_returns_empty(monkeypatch, caplog):
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+
+    def _raise(*_a, **_kw):
+        raise OSError("permission denied")
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _raise)
+    with caplog.at_level("WARNING"):
+        out = llm_provider._call_claude_cli("prompt", "text")
+    assert out == ""
+    assert any("subprocess failed" in rec.message for rec in caplog.records)
+
+
+def test_utf8_emoji_roundtrip(monkeypatch):
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+    captured = {}
+
+    def _fake(args, input, capture_output, text, timeout, encoding, errors):
+        captured["input"] = input
+        captured["encoding"] = encoding
+        return _completed(stdout="hola 👋 ñoño  \n", returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    out = llm_provider._call_claude_cli("Saludá", "ño 🌍 emoji")
+    assert out == "hola 👋 ñoño"  # strip() applied
+    assert captured["input"] == "Saludá\n\nño 🌍 emoji"
+    assert captured["encoding"] == "utf-8"
+
+
+def test_bin_override_honored(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_CLAUDE_CLI_BIN", "/custom/claude")
+    # `which` should NOT be consulted when override is set.
+    monkeypatch.setattr(
+        llm_provider.shutil,
+        "which",
+        lambda _: pytest.fail("which should not be called when override set"),
+    )
+    captured = {}
+
+    def _fake(args, **_kw):
+        captured["argv"] = args
+        return _completed(stdout="ok", returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    out = llm_provider._call_claude_cli("p", "t")
+    assert out == "ok"
+    assert captured["argv"][0] == "/custom/claude"
+
+
+def test_timeout_override_honored(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_CLAUDE_CLI_TIMEOUT", "30")
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+    captured = {}
+
+    def _fake(args, **kw):
+        captured["timeout"] = kw["timeout"]
+        return _completed(stdout="ok", returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    llm_provider._call_claude_cli("p", "t")
+    assert captured["timeout"] == 30
+
+
+def test_model_override_honored(monkeypatch):
+    monkeypatch.setenv("MEMORYMASTER_LLM_MODEL", "claude-sonnet-4-6-20251022")
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+    captured = {}
+
+    def _fake(args, **_kw):
+        captured["argv"] = args
+        return _completed(stdout="ok", returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    llm_provider._call_claude_cli("p", "t")
+    assert "--model" in captured["argv"]
+    model_idx = captured["argv"].index("--model") + 1
+    assert captured["argv"][model_idx] == "claude-sonnet-4-6-20251022"
+
+
+def test_default_model_is_haiku(monkeypatch):
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+    captured = {}
+
+    def _fake(args, **_kw):
+        captured["argv"] = args
+        return _completed(stdout="ok", returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    llm_provider._call_claude_cli("p", "t")
+    model_idx = captured["argv"].index("--model") + 1
+    assert captured["argv"][model_idx] == "claude-haiku-4-5-20251001"
+
+
+def test_provider_aliases_register_same_function():
+    """Both 'claude_cli' and 'claude-cli' must resolve to _call_claude_cli."""
+    assert llm_provider._PROVIDERS["claude_cli"] is llm_provider._call_claude_cli
+    assert llm_provider._PROVIDERS["claude-cli"] is llm_provider._call_claude_cli
+
+
+def test_call_llm_dispatches_to_claude_cli(monkeypatch):
+    """End-to-end: call_llm with provider=claude_cli should route to _call_claude_cli."""
+    monkeypatch.setenv("MEMORYMASTER_LLM_PROVIDER", "claude_cli")
+    monkeypatch.setattr(llm_provider.shutil, "which", lambda _: "/fake/claude")
+
+    def _fake(args, **_kw):
+        return _completed(stdout='[{"answer": 42}]', returncode=0)
+
+    monkeypatch.setattr(llm_provider.subprocess, "run", _fake)
+    out = llm_provider.call_llm("Q:", "What is the answer?")
+    assert out == '[{"answer": 42}]'