memgraph-context-graph 0.12.1__tar.gz → 0.12.2__tar.gz

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.12.1
+Version: 0.12.2
 Summary: Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)
 License: MIT
 License-File: LICENSE

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/docs/memory.md

@@ -111,8 +111,13 @@ its global store, with three differences:
   file is first copied to `config.toml.context-graph-memory.bak`, apart from
   the backup setup's own writes leave. Handing memory back restores those keys
   from it, drops a `[memories]` table the switch created, and deletes the
-  backup. If the user's own `[mcp_servers.context-graph]` narrows tools with
-  `enabled_tools`, `memory` is added there.
+  backup. Repeating the hand-back preserves the restored settings. If the
+  switch backup is missing, including on older installs, current settings stay
+  unchanged. The general `config.toml.context-graph.bak` may predate the switch
+  and is never used to guess the prior settings; the output explains how to
+  turn Codex memories on explicitly when needed. If the user's own
+  `[mcp_servers.context-graph]` narrows tools with `enabled_tools`, `memory` is
+  added there.
 - **Compaction.** The Codex plugin's `SessionStart` hook also fires after
   compaction (`compact`), so the memory index comes back once the context is
   summarized.
@@ -161,7 +166,9 @@ isn't left again.
 
 The backend is one setting for every agent, and the copy runs only while it
 is `context-graph`. So `setup codex claude-code --memory-backend native` hands
-each named agent back first and changes the setting last. An agent left out
+each named agent back first and changes the setting last. Setup stops handing
+back agents at the first failure and keeps the graph backend, so retrying the
+command can still export their memories. An agent left out
 of that command gets nothing copied back once the setting is `native`, so name
 every agent that uses the graph's memory.
 

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memgraph-context-graph"
-version = "0.12.1"
+version = "0.12.2"
 description = "Connect agent SDKs to context-graph components (actions-graph, skills-graph, etc.)"
 readme = "README.md"
 license = { text = "MIT" }

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/adapters/_spec.py

@@ -9,8 +9,10 @@ only declares what differs about it.
 from __future__ import annotations
 
 import json
+import os
 import shlex
 import shutil
+import subprocess
 import sys
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
@@ -69,6 +71,9 @@ class FieldMap:
     reply: tuple[str, ...] = ("last_assistant_message",)
 
 
+_ON_WINDOWS = os.name == "nt"
+
+
 @dataclass(frozen=True)
 class HookConfig:
     """Describe how a runtime represents and stores command hooks.
@@ -78,6 +83,9 @@ class HookConfig:
     ``flat_hooks`` names events written with the flat layout even when
     ``layout`` is nested, for runtimes that only accept matcher groups on some
     events.
+    ``windows_shell`` is the shell the runtime hands hook commands to on
+    Windows. ``cmd.exe`` doesn't read POSIX single quotes, so a ``"cmd"``
+    runtime's commands are quoted for it instead.
     """
 
     layout: Literal["nested", "flat"]
@@ -89,6 +97,7 @@ class HookConfig:
     inject_event_name: bool = False
     matchers: Mapping[str, str] = field(default_factory=dict)
     flat_hooks: frozenset[str] = frozenset()
+    windows_shell: Literal["posix", "cmd"] = "posix"
 
 
 @dataclass(frozen=True)
@@ -300,7 +309,7 @@ def build_hooks_config(spec: RuntimeSpec, command: str, *, timeout: int = 30) ->
     for hook_name in spec.hooks:
         hook_command = command
         if spec.config.inject_event_name:
-            hook_command = f"{command} --event-name {shlex.quote(hook_name)}"
+            hook_command = f"{command} --event-name {_quote(hook_name, spec.config.windows_shell)}"
         command_entry: dict[str, Any] = {"command": hook_command, "type": "command"}
         if spec.config.timeout_key is not None:
             command_entry[spec.config.timeout_key] = timeout
@@ -343,7 +352,11 @@ def write_hook_config(
     if config_path.exists() and not spec.config.merge and not force:
         raise FileExistsError(f"Refusing to overwrite existing {spec.name} config: {config_path} (pass force=True)")
 
-    command = hook_command or hook_command_for(spec.name, connectors)
+    command = hook_command or hook_command_for(spec.name, connectors, windows_shell=spec.config.windows_shell)
+    if hook_command is None and timeout != 30:
+        from memgraph_context_graph.hooks.runner import deadline_for
+
+        command = f"{command} --deadline {deadline_for(timeout):g}"
     hooks = build_hooks_config(spec, command, timeout=timeout)
     document: dict[str, Any]
     if config_path.exists() and spec.config.merge:
@@ -444,9 +457,24 @@ def hook_command_argv(runtime: str, connectors: list[str]) -> list[str]:
     return argv
 
 
-def hook_command_for(runtime: str, connectors: list[str]) -> str:
-    """Build the installed hook command for *runtime* and *connectors* as a shell string."""
-    return shlex.join(hook_command_argv(runtime, connectors))
+def hook_command_for(runtime: str, connectors: list[str], *, windows_shell: Literal["posix", "cmd"] = "posix") -> str:
+    """Build the installed hook command for *runtime* and *connectors* as a shell string.
+
+    On Windows a ``"cmd"`` *windows_shell* gets ``cmd.exe`` quoting, which
+    leaves a path without spaces bare; elsewhere the command is POSIX-quoted.
+    """
+    argv = hook_command_argv(runtime, connectors)
+    if _uses_cmd(windows_shell):
+        return subprocess.list2cmdline(argv)
+    return shlex.join(argv)
+
+
+def _uses_cmd(windows_shell: Literal["posix", "cmd"]) -> bool:
+    return windows_shell == "cmd" and _ON_WINDOWS
+
+
+def _quote(word: str, windows_shell: Literal["posix", "cmd"]) -> str:
+    return subprocess.list2cmdline([word]) if _uses_cmd(windows_shell) else shlex.quote(word)
 
 
 def _metadata_from_payload(payload: dict[str, Any], keys: tuple[str, ...]) -> dict[str, Any]:

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/adapters/antigravity_cli.py

@@ -183,7 +183,8 @@ SPEC = RuntimeSpec(
     ),
     # hooks.json is keyed by named hook groups; this runtime owns one group.
     # Only tool events take matcher groups: agy rejects the whole file if a
-    # lifecycle event is nested, so those are written as flat handlers.
+    # lifecycle event is nested, so those are written as flat handlers. On
+    # Windows agy runs each command through cmd.exe, inside its own quotes.
     config=HookConfig(
         path=".agents/hooks.json",
         layout="nested",
@@ -191,6 +192,7 @@ SPEC = RuntimeSpec(
         merge=True,
         inject_event_name=True,
         flat_hooks=frozenset({"SessionStart", "Stop"}),
+        windows_shell="cmd",
     ),
     fields=FieldMap(session_id=("conversationId",)),
     # PostToolUse requires an object; an empty PreToolUse answer leaves agy's

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/adapters/claude_code_memory.py

@@ -265,14 +265,30 @@ def _lineage(files: MemoryFiles, path: str) -> set[str]:
 
 
 def _checkout_for(slug: str) -> Path | None:
-    """The directory Claude Code named *slug*, found by walking the filesystem from ``/``.
+    """The directory Claude Code named *slug*, found by walking the filesystem from its root.
 
     The slug is lossy: ``/repos/ai-toolkit`` and ``/repos/ai/toolkit`` give
     the same one. So each step matches the directory's real entries by their
     own slugs, preferring the longest, and backtracks when a path dead-ends.
     """
-    tokens = slug.lstrip("-").split("-")
-    return _walk(Path("/"), tokens) if tokens and tokens[0] else None
+    start = _slug_root(slug)
+    return _walk(*start) if start else None
+
+
+def _slug_root(slug: str) -> tuple[Path, list[str]] | None:
+    """The filesystem root *slug* starts from, and the tokens left to walk below it.
+
+    A POSIX slug starts with the ``-`` of ``/``. A Windows one starts with the
+    drive letter, and the drive's ``:\\`` makes a double dash: ``C:\\source\\x`` is
+    ``C--source-x``.
+    """
+    if slug.startswith("-"):
+        tokens = slug[1:].split("-")
+        return (Path("/"), tokens) if tokens[0] else None
+    drive, double_dash, rest = slug.partition("--")
+    if len(drive) == 1 and drive.isalpha() and double_dash and rest:
+        return Path(f"{drive}:/"), rest.split("-")
+    return None
 
 
 def _walk(directory: Path, tokens: list[str]) -> Path | None:

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/adapters/codex_memory.py

@@ -104,15 +104,25 @@ class CodexMemory:
 
         Keys that didn't exist then are removed, which leaves Codex's own
         defaults (``features.memories`` is off by default), and so is a table
-        the switch created and left empty.
+        the switch created and left empty. Without a switch backup, settings
+        are preserved; the output explains how to enable memories if needed.
 
         Raises:
             MemoryBackendError: the config file or its backup isn't valid TOML.
         """
         path = _config_path(home)
         switch_backup = _switch_backup(path)
-        before = _read(switch_backup)
         config = _read(path)
+        if not switch_backup.exists():
+            lines = [f"Unchanged {path}: no memory-switch backup; kept the current memory settings."]
+            if any(_get(config, keys, None) is False for keys, _off in _SWITCHES):
+                lines.append(
+                    f"To turn Codex memories on, review {path} and set features.memories, memories.use_memories"
+                    " and memories.generate_memories to true. An older config.toml.context-graph.bak may predate"
+                    " the memory switch, so it wasn't restored automatically."
+                )
+            return lines
+        before = _read(switch_backup)
         for keys, _off in _SWITCHES:
             previous = _get(before, keys, None)
             if previous is None:
@@ -169,7 +179,7 @@ class CodexMemory:
         Codex still has them.
         """
         notes = _memory_root(home).joinpath(*_NOTES_DIR)
-        left = {path.read_text(encoding="utf-8") for path in notes.glob(f"*-{_NOTE_PREFIX}*.md")}
+        left = {_read_text(path) for path in notes.glob(f"*-{_NOTE_PREFIX}*.md")}
         stamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H-%M-%S")
         report = ExportReport()
         for memory in source.files():

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/connectors.py

@@ -60,7 +60,7 @@ class ConnectorSpec:
 INSTALLABLE: dict[str, str] = {
     "skills-graph": "skills-graph[memgraph-context-graph]>=0.4.0",
     "actions-graph": "actions-graph[memgraph-context-graph]>=0.7.1",
-    "sessions-graph": "sessions-graph[memgraph-context-graph]>=0.12.1",
+    "sessions-graph": "sessions-graph[memgraph-context-graph]>=0.12.2",
     "resources-graph": "resources-graph[memgraph-context-graph]>=0.3.0",
 }
 

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/hooks/runner.py

@@ -6,6 +6,7 @@ import argparse
 import json
 import os
 import sys
+import threading
 import time
 from typing import TYPE_CHECKING, Any, NoReturn, TypedDict
 
@@ -36,6 +37,16 @@ if TYPE_CHECKING:
 #: so the runtime killed it before the failure could be logged (#378).
 HOOK_CONNECT_TIMEOUT = 5.0
 
+#: Seconds a hook runs before it logs where it was stuck, answers the runtime, and exits, for the 30 s hook
+#: timeout our plugins declare. A query waiting on Memgraph's storage access never raises, so without a deadline
+#: of its own the hook is killed at the runtime's timeout and nothing is logged.
+HOOK_DEADLINE = 25.0
+
+
+def deadline_for(timeout: float) -> float:
+    """The ``--deadline`` for a hook the runtime kills after *timeout* seconds: enough margin to log and answer."""
+    return max(timeout - 5.0, timeout / 2)
+
 
 def load_payload(stream: Any | None = None) -> dict[str, Any]:
     """Read one JSON hook payload from a text stream (stdin by default)."""
@@ -160,6 +171,13 @@ def _hook_parser(plugin: RuntimeCLIPlugin) -> argparse.ArgumentParser:
     parser.add_argument("--memgraph-user", default=None, help="Memgraph username. Overrides config file value.")
     parser.add_argument("--memgraph-password", default=None, help="Memgraph password. Overrides config file value.")
     parser.add_argument("--memgraph-database", default=None, help="Memgraph database. Overrides config file value.")
+    parser.add_argument(
+        "--deadline",
+        type=float,
+        default=HOOK_DEADLINE,
+        help=f"Seconds before the hook gives up, logs why, and answers the runtime (default: {HOOK_DEADLINE:g}). "
+        "Keep it under the runtime's hook timeout.",
+    )
     parser.add_argument(
         "--strict",
         action="store_true",
@@ -198,6 +216,54 @@ class _FailureReport:
             self.record("emit", exc, connector=name, event_type=event.event_type.value, session_id=event.session_id)
 
 
+class _Deadline:
+    """Answers the runtime and ends the process once a hook has run too long, logging the stage it was stuck in.
+
+    Every response goes through :meth:`respond`, so the runtime reads one
+    answer whichever of the hook and the deadline gets there first.
+    """
+
+    def __init__(self, plugin: RuntimeCLIPlugin, report: _FailureReport) -> None:
+        self._plugin = plugin
+        self._report = report
+        self._lock = threading.Lock()
+        self._responded = False
+        self._timer: threading.Timer | None = None
+
+    def start(self, seconds: float) -> None:
+        self._timer = threading.Timer(seconds, self._expire, args=(seconds,))
+        self._timer.daemon = True
+        self._timer.start()
+
+    def cancel(self) -> None:
+        if self._timer is not None:
+            self._timer.cancel()
+
+    def respond(self, response: dict[str, Any]) -> None:
+        with self._lock:
+            if self._responded:
+                return
+            self._responded = True
+            if response:
+                print(json.dumps(response))
+
+    def _expire(self, seconds: float) -> None:
+        # Never released once answering here: the hook's own thread may still be blocked and must not answer too.
+        self._lock.acquire()
+        if self._responded:
+            self._lock.release()
+            return
+        self._report.record(
+            self._report.stage, error_type="HookDeadline", error=f"hook still running after {seconds:g} s"
+        )
+        # The plain response: the session-start text would query the graph that is holding the hook up.
+        response = self._plugin.response_for_payload(self._report.payload) or {}
+        if response:
+            print(json.dumps(response))
+        sys.stdout.flush()
+        os._exit(0)
+
+
 def _text(value: Any) -> str | None:
     return value if isinstance(value, str) else None
 
@@ -216,14 +282,21 @@ def run_hook(plugin: RuntimeCLIPlugin, argv: Sequence[str] | None = None) -> int
     normal response, and the exit status is 0. ``--strict`` (or the
     ``_STRICT`` env flag) re-raises after logging, for developers; a connector
     failure then raises :class:`ConnectorFailuresError` once every connector has run.
+
+    A hook that blocks, on a query waiting for Memgraph's storage access, never
+    raises: at ``--deadline`` it logs a ``HookDeadline`` failure at the stage it
+    was stuck in, prints the runtime's plain response, and exits 0 itself,
+    before the runtime's own timeout would kill it unlogged.
     """
     report = _FailureReport(plugin.name)
+    deadline = _Deadline(plugin, report)
     strict = os.environ.get(f"{_env_prefix(plugin.name)}_STRICT") == "1"
     payload: dict[str, Any] = {}
     connector_names: list[str] = []
     try:
         args = _hook_parser(plugin).parse_args(argv)
         strict = strict or args.strict
+        deadline.start(args.deadline)
 
         from memgraph_context_graph.adapters._identity import load_config, resolve_memgraph_env
 
@@ -245,7 +318,7 @@ def run_hook(plugin: RuntimeCLIPlugin, argv: Sequence[str] | None = None) -> int
         if problems := [*load_config().problems, *policy_problems]:
             report.record("config", level="warning", error_type="MalformedConfig", error="; ".join(problems))
         if policy.excludes_project(_with_cwd(payload)["cwd"]):
-            _print_response(plugin, payload, connector_names)
+            deadline.respond(_response(plugin, payload, connector_names))
             return 0
 
         report.stage = "setup"
@@ -258,7 +331,9 @@ def run_hook(plugin: RuntimeCLIPlugin, argv: Sequence[str] | None = None) -> int
         adapter = plugin.adapter_class(link, session_id=args.session_id)
         adapter.handle_payload(payload)
         report.stage = "respond"
-        _print_response(plugin, payload, connector_names, before_tool=_context_before_tool(link, tool_starts.events))
+        deadline.respond(
+            _response(plugin, payload, connector_names, before_tool=_context_before_tool(link, tool_starts.events))
+        )
     except Exception as exc:
         if report.stage in {"args", "config"}:
             # Failed before stdin was read: read it now, so the runtime still gets the response its event expects
@@ -269,9 +344,11 @@ def run_hook(plugin: RuntimeCLIPlugin, argv: Sequence[str] | None = None) -> int
         report.record(report.stage, exc, error_type="HookArgumentError" if report.stage == "args" else None)
         if strict:
             raise
-        _print_response(plugin, payload, connector_names)
+        deadline.respond(_response(plugin, payload, connector_names))
         _debug_log(plugin.name, f"memgraph-context-graph {plugin.name} hook skipped: {exc}")
         return 0
+    finally:
+        deadline.cancel()
     if strict and report.connector_failures:
         raise ConnectorFailuresError(report.connector_failures)
     return 0
@@ -293,9 +370,9 @@ def _payload_session_id(payload: dict[str, Any]) -> str | None:
     return None
 
 
-def _print_response(
+def _response(
     plugin: RuntimeCLIPlugin, payload: dict[str, Any], connector_names: list[str], *, before_tool: Sequence[str] = ()
-) -> None:
+) -> dict[str, Any]:
     response = plugin.response_for_payload(payload) or {}
     render_session = getattr(plugin, "session_context_response", None)
     if render_session is not None:
@@ -303,8 +380,7 @@ def _print_response(
     render = getattr(plugin, "context_before_tool_response", None)
     if before_tool and render is not None:
         response.update(render("\n".join(before_tool)) or {})
-    if response:
-        print(json.dumps(response))
+    return response
 
 
 class _ToolStarts(GraphConnector):

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/setup/engine.py

@@ -203,7 +203,10 @@ def run(
     if choices.memory_backend:
         switchable = [runtime for runtime in choices.runtimes if has_native_memory(runtime)]
         for runtime in switchable:
-            done(_memory(runtime, choices.memory_backend, last=runtime == switchable[-1]))
+            outcome = done(_memory(runtime, choices.memory_backend, last=runtime == switchable[-1]))
+            # Later hand-backs must still see the graph as the backend when this one is retried.
+            if outcome.status == "fail" and choices.memory_backend == "native":
+                break
     for outcome in verify(choices.runtimes):
         done(outcome)
     return outcomes

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/setup/tool.py

@@ -17,11 +17,11 @@ if TYPE_CHECKING:
     from collections.abc import Callable
 
 #: Kept in step with the plugins' bootstrap scripts and install.sh, which install the default connectors first.
-BASE = "memgraph-context-graph[mcp]>=0.12.1"
+BASE = "memgraph-context-graph[mcp]>=0.12.2"
 VIEWER = ("context-graph-viewer", "context-graph-viewer>=0.1.1")
 SPACES = ("context-graph-spaces", "context-graph-spaces>=0.1.2")
 #: sessions-graph's local extraction, which setup doesn't install itself; ``unstructured2graph`` tells it is there.
-RECONCILIATION = ("unstructured2graph", "sessions-graph[memgraph-context-graph,reconciliation]>=0.12.1")
+RECONCILIATION = ("unstructured2graph", "sessions-graph[memgraph-context-graph,reconciliation]>=0.12.2")
 #: Connectors whose own command people run: ``sessions-graph reconcile``, ``resources-graph sweep``.
 EXECUTABLES = ("sessions-graph", "resources-graph")
 

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/tests/test_antigravity_cli_adapter.py

@@ -6,6 +6,7 @@ Payload shapes are trimmed from a live agy 1.2.13 session.
 import json
 
 from memgraph_context_graph import AgentLink
+from memgraph_context_graph.adapters import _spec
 from memgraph_context_graph.adapters.antigravity_cli import PLUGIN, AntigravityCLIHooksAdapter, init
 from memgraph_context_graph.events import (
     ErrorOccurredEvent,
@@ -162,3 +163,18 @@ def test_init_writes_a_named_group_with_flat_lifecycle_hooks(tmp_path):
     # agy rejects a nested entry on a lifecycle event, and with it the whole file.
     assert group["Stop"] == [{"command": "capture --event-name Stop", "type": "command", "timeout": 12}]
     assert group["SessionStart"] == [{"command": "capture --event-name SessionStart", "type": "command", "timeout": 12}]
+
+
+def test_init_on_windows_writes_commands_cmd_exe_can_run(tmp_path, monkeypatch):
+    # agy hands each command to cmd.exe inside its own quotes: a POSIX-quoted
+    # 'C:\...' path is not a filename there, and a double-quoted one is quoted twice.
+    exe = r"C:\Users\dev\.local\bin\memgraph-context-graph.EXE"
+    monkeypatch.setattr(_spec, "_ON_WINDOWS", True)
+    monkeypatch.setattr(_spec.shutil, "which", lambda name: exe)
+
+    init(tmp_path, ["actions-graph"])
+
+    group = json.loads((tmp_path / ".agents" / "hooks.json").read_text())["memgraph-context-graph"]
+    assert group["Stop"][0]["command"] == (
+        rf"{exe} hook run antigravity-cli --connector actions-graph --event-name Stop"
+    )

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/tests/test_capture_log.py

@@ -284,6 +284,49 @@ def test_a_blackholed_memgraph_fails_inside_the_hook_timeout(monkeypatch, tmp_pa
     assert [line["stage"] for line in _lines(_capture_log_in_tmp)] == ["connect"]
 
 
+def test_a_hook_blocked_past_its_deadline_answers_and_logs_where(tmp_path):
+    """A query waiting on Memgraph's storage never raises, so the runtime killed the hook at its timeout, unlogged.
+
+    Run as its own process: the deadline ends the process, as it must to beat a hook thread that is still blocked.
+    """
+    log = tmp_path / "capture-failures.jsonl"
+    hook = textwrap.dedent(
+        f"""
+        import dataclasses, sys, threading
+        from pathlib import Path
+        from memgraph_context_graph import AgentLink, capture_log
+        from memgraph_context_graph.adapters.claude_code import PLUGIN
+        from memgraph_context_graph.hooks import runner
+
+        capture_log._path_override = Path({str(log)!r})
+        runner.create_link = lambda *args, **kwargs: AgentLink()
+
+        class BlockedAdapter:
+            def __init__(self, link, session_id=None):
+                pass
+
+            def handle_payload(self, payload):
+                threading.Event().wait()
+
+        sys.exit(runner.run_hook(dataclasses.replace(PLUGIN, adapter_class=BlockedAdapter), ["--deadline", "1"]))
+        """
+    )
+
+    start = time.monotonic()
+    done = subprocess.run(
+        [sys.executable, "-c", hook],
+        input='{"hook_event_name":"Stop","session_id":"s1"}',
+        capture_output=True,
+        text=True,
+        timeout=60,
+    )
+
+    assert time.monotonic() - start < 30
+    assert (done.returncode, done.stdout.strip()) == (0, '{"continue": true}')
+    (line,) = _lines(log)
+    assert (line["stage"], line["error_type"], line["session_id"]) == ("translate", "HookDeadline", "s1")
+
+
 @pytest.mark.skipif(os.name == "nt", reason="POSIX permissions")
 def test_writer_cost_is_small(_capture_log_in_tmp):
     start = time.perf_counter()

memgraph_context_graph-0.12.2/tests/test_claude_code_memory.py

@@ -0,0 +1,31 @@
+"""Tests for reading Claude Code's project-folder slugs back into checkouts.
+
+Walking a slug against a real checkout is covered end to end in sessions-graph's
+memory backend tests; a Windows drive can't be walked off Windows, so its root is
+tested here.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from memgraph_context_graph.adapters.claude_code_memory import _slug_root
+
+
+@pytest.mark.parametrize(
+    ("slug", "root"),
+    [
+        ("-Users-dev-repos-ai-toolkit", (Path("/"), ["Users", "dev", "repos", "ai", "toolkit"])),
+        ("C--source-x", (Path("C:/"), ["source", "x"])),
+        ("d--work-my-repo", (Path("d:/"), ["work", "my", "repo"])),
+        # A dot-folder after the drive makes a third dash: C:\.config\x.
+        ("C---config-x", (Path("C:/"), ["", "config", "x"])),
+    ],
+)
+def test_a_slug_walks_from_the_root_its_path_started_at(slug, root):
+    assert _slug_root(slug) == root
+
+
+@pytest.mark.parametrize("slug", ["-", "", "C--", "source-x", "CD--x"])
+def test_a_slug_with_no_root_has_no_checkout(slug):
+    assert _slug_root(slug) is None

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/tests/test_codex_adapter.py

@@ -1,9 +1,10 @@
 """Tests for the OpenAI Codex hooks adapter."""
 
 import io
+import json
 
 from memgraph_context_graph import AgentLink
-from memgraph_context_graph.adapters.codex import PLUGIN, CodexHooksAdapter
+from memgraph_context_graph.adapters.codex import PLUGIN, CodexHooksAdapter, init
 from memgraph_context_graph.events import (
     Event,
     EventType,
@@ -212,3 +213,14 @@ def test_load_payload_requires_json_object():
     payload = load_payload(io.StringIO('{"hook_event_name": "Stop"}'))
 
     assert payload == {"hook_event_name": "Stop"}
+
+
+def test_init_with_a_shorter_timeout_gives_the_hook_a_deadline_inside_it(tmp_path):
+    init(tmp_path, ["actions-graph"], timeout=10)
+    init(tmp_path / "default", ["actions-graph"])
+
+    def stop_command(project):
+        return json.loads((project / ".codex" / "hooks.json").read_text())["hooks"]["Stop"][0]["hooks"][0]["command"]
+
+    assert stop_command(tmp_path).endswith("--connector actions-graph --deadline 5")
+    assert stop_command(tmp_path / "default").endswith("--connector actions-graph")

memgraph_context_graph-0.12.2/tests/test_codex_memory.py

@@ -0,0 +1,69 @@
+"""Codex memory switches preserve user settings in a throwaway home."""
+
+from __future__ import annotations
+
+import pytest
+
+from memgraph_context_graph.adapters.codex_memory import CodexMemory
+
+
+@pytest.fixture
+def codex_config(tmp_path, monkeypatch):
+    monkeypatch.delenv("CODEX_HOME", raising=False)
+    path = tmp_path / ".codex" / "config.toml"
+    path.parent.mkdir()
+    return tmp_path, path
+
+
+@pytest.mark.parametrize(
+    "original",
+    [
+        "[features]\nmemories = true\n",
+        "[features]\nmemories = false\n[memories]\nuse_memories = false\ngenerate_memories = false\n",
+    ],
+)
+def test_repeating_hand_back_preserves_restored_settings(codex_config, original):
+    home, config = codex_config
+    config.write_text(original)
+    # Setup's older backup must not become the restoration source on a later retry.
+    config.with_name(config.name + ".context-graph.bak").write_text("[features]\nmemories = true\n")
+    native = CodexMemory()
+    native.disable(home)
+    native.enable(home)
+    restored = config.read_bytes()
+
+    native.enable(home)
+
+    assert config.read_bytes() == restored
+
+
+def test_hand_back_without_a_switch_preserves_native_settings(codex_config):
+    home, config = codex_config
+    original = b"[features]\nmemories = true\n[memories]\ngenerate_memories = false\n"
+    config.write_bytes(original)
+
+    CodexMemory().enable(home)
+
+    assert config.read_bytes() == original
+
+
+def test_hand_back_without_a_config_does_not_create_one(codex_config):
+    home, config = codex_config
+
+    CodexMemory().enable(home)
+
+    assert not config.exists()
+
+
+def test_a_legacy_backup_is_not_restored_as_the_missing_switch_backup(codex_config):
+    home, config = codex_config
+    original = b"[features]\nmemories = false\n[memories]\nuse_memories = false\ngenerate_memories = false\n"
+    config.write_bytes(original)
+    backup = config.with_name(config.name + ".context-graph.bak")
+    backup.write_text("[features]\nmemories = true\n")
+
+    lines = CodexMemory().enable(home)
+
+    assert config.read_bytes() == original
+    assert backup.read_text() == "[features]\nmemories = true\n"
+    assert any("To turn Codex memories on" in line and "wasn't restored automatically" in line for line in lines)

{memgraph_context_graph-0.12.1 → memgraph_context_graph-0.12.2}/tests/test_setup.py

@@ -93,7 +93,7 @@ def test_wiring_refuses_the_home_directory(setup_home):
 
 
 @pytest.mark.parametrize("runtime, binary", [("claude-code", "claude"), ("codex", "codex")])
-def test_plugin_wiring_registers_installs_and_comes_off_again(fake_agents, runtime, binary):
+def test_plugin_wiring_registers_installs_and_comes_off_again(fake_agents, setup_home, runtime, binary):
     agent = BY_RUNTIME[runtime]
     lines, log = _logged()