memtrust-cli 0.3.3__tar.gz → 0.3.4__tar.gz

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memtrust-cli
-Version: 0.3.3
+Version: 0.3.4
 Summary: Independent, reproducible benchmark harness for agent-memory backends (MemPalace, Mem0, Zep/Graphiti, OpenViking): runs LongMemEval, LoCoMo, contradiction-detection, and a dozen other evals against all four and publishes the raw logs, not vendor-curated numbers.
 Project-URL: Homepage, https://github.com/RudrenduPaul/memtrust
 Project-URL: Issues, https://github.com/RudrenduPaul/memtrust/issues
@@ -11,6 +11,7 @@ License: Apache-2.0
 License-File: LICENSE
 Keywords: agent-memory,ai-agents,benchmark,contradiction-detection,graphiti,llm-eval,llm-memory,locomo,longmemeval,mem0,memory-backend,mempalace,reproducible-benchmark,zep
 Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
@@ -607,10 +608,12 @@ distribution name is installed. `memtrust --version` now matches `pip show` unde
 name.
 
 **Can I `pip install memtrust` instead of `memtrust-cli`?** Yes -- `memtrust` is a real, separate
-PyPI package, kept at the same version as `memtrust-cli` on every release, publishing the identical
-source. It exists because the npm wrapper's `bin/memtrust.js` pins `uv tool run --from
-memtrust==<version>` (not `memtrust-cli`), so a working `npx memtrust-cli` depends on the
-`memtrust` name staying live and in sync. `memtrust-cli` is the name to lead with in new
+PyPI package, publishing the identical source and currently in sync with `memtrust-cli`'s version.
+That sync is a manual release step, not an automated guarantee (see CONTRIBUTING.md's Release
+process for exactly how, and why it has drifted stale before) -- so "currently in sync" is the
+honest framing, not "always in sync." It exists because the npm wrapper's `bin/memtrust.js` pins
+`uv tool run --from memtrust==<version>` (not `memtrust-cli`), so a working `npx memtrust-cli`
+depends on the `memtrust` name staying live and in sync. `memtrust-cli` is the name to lead with in new
 documentation, since the `-cli` suffix makes it unambiguous as a CLI tool at a glance; `memtrust`
 is a legitimate, supported install path, not a typo or a squatted name.
 

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/README.md

@@ -562,10 +562,12 @@ distribution name is installed. `memtrust --version` now matches `pip show` unde
 name.
 
 **Can I `pip install memtrust` instead of `memtrust-cli`?** Yes -- `memtrust` is a real, separate
-PyPI package, kept at the same version as `memtrust-cli` on every release, publishing the identical
-source. It exists because the npm wrapper's `bin/memtrust.js` pins `uv tool run --from
-memtrust==<version>` (not `memtrust-cli`), so a working `npx memtrust-cli` depends on the
-`memtrust` name staying live and in sync. `memtrust-cli` is the name to lead with in new
+PyPI package, publishing the identical source and currently in sync with `memtrust-cli`'s version.
+That sync is a manual release step, not an automated guarantee (see CONTRIBUTING.md's Release
+process for exactly how, and why it has drifted stale before) -- so "currently in sync" is the
+honest framing, not "always in sync." It exists because the npm wrapper's `bin/memtrust.js` pins
+`uv tool run --from memtrust==<version>` (not `memtrust-cli`), so a working `npx memtrust-cli`
+depends on the `memtrust` name staying live and in sync. `memtrust-cli` is the name to lead with in new
 documentation, since the `-cli` suffix makes it unambiguous as a CLI tool at a glance; `memtrust`
 is a legitimate, supported install path, not a typo or a squatted name.
 

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/npm/memtrust-cli/package.json

@@ -8,6 +8,10 @@
   "os": ["darwin", "linux", "win32"],
   "cpu": ["x64", "arm64"],
   "license": "Apache-2.0",
+  "author": "Rudrendu Paul",
+  "contributors": [
+    "Sourav Nandy"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/RudrenduPaul/memtrust.git"

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "memtrust-cli"
-version = "0.3.3"
+version = "0.3.4"
 description = "Independent, reproducible benchmark harness for agent-memory backends (MemPalace, Mem0, Zep/Graphiti, OpenViking): runs LongMemEval, LoCoMo, contradiction-detection, and a dozen other evals against all four and publishes the raw logs, not vendor-curated numbers."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -20,6 +20,7 @@ keywords = [
 ]
 classifiers = [
     "Development Status :: 4 - Beta",
+    "Environment :: Console",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python :: 3",

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/src/memtrust/cli.py

@@ -503,7 +503,13 @@ def main() -> None:
     "eval_arg",
     default="all",
     show_default=True,
-    help=f"Comma-separated eval list ({','.join(ALL_EVALS)}), or 'all'.",
+    # ", ".join, not ",".join -- click's --help text wrapper only breaks
+    # lines on whitespace, so a bare comma-joined list with no spaces
+    # wraps mid-word (e.g. "longmemeval,locom" / "o,contradiction,...").
+    # The parser itself (_resolve_eval_names) already .strip()s each
+    # token, so accepting "a, b" on the command line still works too --
+    # this only changes what gets displayed, not what's parsed.
+    help=f"Comma-separated eval list ({', '.join(ALL_EVALS)}), or 'all'.",
 )
 @click.option(
     "--output",
@@ -953,14 +959,22 @@ def run(
 
 @main.command()
 @click.argument("report_path", type=click.Path(exists=True, dir_okay=False, path_type=Path))
-def report(report_path: Path) -> None:
+@click.option("--json", "json_mode", is_flag=True, default=False, help="Print the parsed report as JSON instead of a formatted summary.")
+def report(report_path: Path, json_mode: bool) -> None:
     """Read a prior `memtrust run` JSON report and print a formatted summary."""
     try:
         data = json.loads(report_path.read_text())
     except json.JSONDecodeError as exc:
-        console.print(f"[red]Could not parse {report_path} as JSON: {exc}[/red]")
+        if json_mode:
+            print(json.dumps({"ok": False, "error": f"Could not parse {report_path} as JSON: {exc}"}))
+        else:
+            console.print(f"[red]Could not parse {report_path} as JSON: {exc}[/red]")
         sys.exit(1)
 
+    if json_mode:
+        print(json.dumps(data, default=str))
+        return
+
     console.print(f"[bold]memtrust report[/bold] -- run_id={data.get('run_id', 'unknown')}")
     console.print(f"Generated: {data.get('timestamp', 'unknown')}\n")
 
@@ -1218,7 +1232,8 @@ def keygen(private_key_path: Path, public_key_path: Path, force: bool) -> None:
         "Never taken from the receipt file itself: a receipt cannot vouch for its own key."
     ),
 )
-def verify(receipt_path: Path, public_key_path: Path | None) -> None:
+@click.option("--json", "json_mode", is_flag=True, default=False, help="Print the verification result as JSON instead of formatted text.")
+def verify(receipt_path: Path, public_key_path: Path | None, json_mode: bool) -> None:
     """Verify a signed receipt produced by `memtrust run --sign`.
 
     Proves exactly two things when valid: the receipt's payload has not
@@ -1233,9 +1248,26 @@ def verify(receipt_path: Path, public_key_path: Path | None) -> None:
     try:
         result = verify_receipt_file(receipt_path, public_key_path=public_key_path)
     except ReceiptError as exc:
-        console.print(f"[red]Could not verify: {exc}[/red]")
+        if json_mode:
+            print(json.dumps({"ok": False, "error": str(exc)}))
+        else:
+            console.print(f"[red]Could not verify: {exc}[/red]")
         sys.exit(1)
 
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "valid": result.valid,
+                    "reason": result.reason,
+                    "embedded_key_matches_trusted_key": result.embedded_key_matches_trusted_key,
+                }
+            )
+        )
+        if not result.valid:
+            sys.exit(1)
+        return
+
     color = "green" if result.valid else "red"
     console.print(f"[{color}]valid: {result.valid}[/{color}]")
     console.print(result.reason)

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/tests/test_cli.py

@@ -11,9 +11,11 @@ from pathlib import Path
 import pytest
 from click.testing import CliRunner
 from pytest_httpx import HTTPXMock
+from test_temporal_kg_boundary import _RealSemanticsFakeKGTools
 
 from memtrust.adapters.base import TemporalBoundarySignal
-from memtrust.cli import ALL_EVALS, _serialize_eval_result, main
+from memtrust.adapters.mempalace_adapter import MemPalaceAdapter
+from memtrust.cli import ADAPTER_REGISTRY, ALL_EVALS, _serialize_eval_result, main
 from memtrust.evals.temporal_kg_boundary import (
     TemporalKGBoundaryCase,
     TemporalKGBoundaryCaseResult,
@@ -390,6 +392,56 @@ def test_serialize_eval_result_handles_temporal_kg_boundary_result() -> None:
     assert serialized["cases"][0]["self_report_agrees"] is False
 
 
+def test_run_temporal_kg_boundary_end_to_end_against_configured_mempalace(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """The `not_applicable`/no-credentials tests above only exercise the
+    SKIP paths -- neither ever reaches the `isinstance(adapter,
+    MemPalaceAdapter)` branch that actually calls
+    `run_temporal_kg_boundary_eval()` for real. This drives that branch
+    for real: injects `MemPalaceAdapter(mcp_tools=...)` with the same
+    closed-interval fake `test_temporal_kg_boundary.py` uses to reproduce
+    the real MemPalace/mempalace#1913 bug shape, so the eval's actual
+    classification logic runs end to end through the CLI, not a
+    hand-built result."""
+    case = TemporalKGBoundaryCase(
+        case_id="cli-e2e-1",
+        subject="cli-e2e-subject",
+        predicate="uses_model",
+        old_object="claude-opus-4-7",
+        new_object="claude-opus-4-8",
+        seed_valid_from="2026-05-01T00:00:00Z",
+        boundary="2026-06-02T12:00:00Z",
+    )
+    adapter = MemPalaceAdapter(mcp_tools=_RealSemanticsFakeKGTools(boundary_mode="closed"))
+    monkeypatch.setitem(ADAPTER_REGISTRY, "mempalace", lambda: adapter)
+    monkeypatch.setattr(
+        "memtrust.evals.temporal_kg_boundary.default_cases",
+        lambda *args, **kwargs: [case],
+    )
+
+    runner = CliRunner()
+    out_path = tmp_path / "report.json"
+    result = runner.invoke(
+        main,
+        [
+            "run",
+            "--backends",
+            "mempalace",
+            "--eval",
+            "temporal_kg_boundary",
+            "--output",
+            str(out_path),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    data = json.loads(out_path.read_text())
+    tkgb = data["results"]["mempalace"]["evals"]["temporal_kg_boundary"]
+    assert tkgb["double_count_rate"] == 1.0
+    assert tkgb["cases"][0]["signal"] == "double_count"
+
+
 def test_run_against_configured_backend_full_flow(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch, httpx_mock: HTTPXMock
 ) -> None:

{memtrust_cli-0.3.3 → memtrust_cli-0.3.4}/tests/test_init.py

@@ -18,6 +18,26 @@ from typing import NoReturn
 import pytest
 
 
+@pytest.fixture(autouse=True)
+def _restore_real_version_after_reload() -> object:
+    """`importlib.reload()` mutates the real, live `memtrust` module object
+    in place -- `monkeypatch`'s own teardown only undoes the
+    `importlib.metadata.version` patch, it does not know the reload already
+    baked a fake `__version__` into the shared module singleton, so without
+    this fixture a test in this file leaves `memtrust.__version__` wrong for
+    every test that runs afterward in the same pytest process (confirmed:
+    `test_cli.py::test_version_flag` fails when run after this file, passes
+    in isolation). Captures the real value before the test, restores it
+    unconditionally after -- independent of monkeypatch's own teardown
+    order, since it does not rely on triggering another reload to fix it.
+    """
+    import memtrust
+
+    real_version = memtrust.__version__
+    yield
+    memtrust.__version__ = real_version
+
+
 def _reload_memtrust_with_patched_version(
     monkeypatch: pytest.MonkeyPatch, fake_version: object
 ) -> str: