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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memgraph-context-graph
-Version: 0.12.0
+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.0 → memgraph_context_graph-0.12.2}/docs/memory.md

@@ -89,7 +89,9 @@ back on, since without the plugin it would have none.)
 
 Opting in does three things, in this order:
 1. Imports the existing auto-memory files from every project once:
-   - `user`/`feedback` memories go to `/memories/<type>/`;
+   - `user`/`feedback` memories go to `/memories/<type>/`. When another
+     project already put a different memory of the same name there, this one
+     goes to its own project's folder instead, so neither is lost;
    - `project`/`reference` memories go to that project's folder;
    - `MEMORY.md` is skipped, and anything already in the graph is never overwritten.
 2. Sets `autoMemoryEnabled: false` in `~/.claude/settings.json`, the user-level
@@ -100,12 +102,20 @@ Opting in does three things, in this order:
 For Codex, `setup codex --memory-backend context-graph` does the same against
 its global store, with three differences:
 - **Import.** `memory_summary.md`, the profile Codex injected each session,
-  becomes `/memories/user/codex-memory-summary.md`, and `MEMORY.md` becomes
-  `/memories/codex/memory.md`.
+  becomes `/memories/codex/memory-summary.md`, and `MEMORY.md` becomes
+  `/memories/codex/memory.md`. Both stay under `/memories/codex/` rather than
+  the user-wide root, since Codex wrote them across every project.
 - **Switch.** It turns off `features.memories`, `memories.use_memories` and
   `memories.generate_memories` in `~/.codex/config.toml` (or under
-  `$CODEX_HOME`), keeping the user's comments and layout. Handing memory back
-  restores whatever those keys were before. If the user's own
+  `$CODEX_HOME`), keeping the user's comments, layout and line endings. The
+  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. 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
@@ -123,20 +133,44 @@ Nothing writes to both memories: while the backend is `context-graph`, the
 graph is the only one. Handing memory back (`--memory-backend native`, or
 `uninstall`) first copies the graph's memories into Claude Code's auto memory,
 the reverse of the import, so it picks up where the graph left off:
-- a project's files go to every Claude Code project folder with that project
-  key, `user`/`feedback` ones to every folder with auto memory, each with its
-  `<type>_` prefix back;
-- the graph's copy wins over the older one there, and each folder's
-  `MEMORY.md` is rebuilt;
-- files Claude Code has no folder for (a project it never opened, another
-  agent's files) stay in the graph only, and the output lists them.
-
-Then it removes the setting. The copy runs only while the backend is
-`context-graph`, so handing back twice never overwrites newer files. If
-Memgraph is down, `setup` switches nothing; `uninstall` turns the memory back
-on anyway, with what it held before, and warns. Codex, Copilot CLI and Grok
-Build get nothing copied back: their memory is generated or hosted by the
-agent itself.
+- Claude Code keeps one memory folder per git repository, shared by its
+  worktrees and subdirectories, so a project's files go to that repository's
+  folder only, each with its `<type>_` prefix back;
+- `user`/`feedback` files go back to the folders they were imported from. One
+  first written while the graph was the backend goes to the repositories of
+  the sessions that wrote it. Claude Code has no memory that applies
+  everywhere, so these files are not copied into every project;
+- a file already there is replaced only when it is an earlier text of the
+  graph's file. Any other file, changed outside the graph, is kept, and the
+  output lists it. Each folder that changed gets its `MEMORY.md` rebuilt;
+- files with no folder to go to (a project Claude Code never opened, a
+  user-wide file no recorded session wrote, another agent's files) stay in
+  the graph only, and the output lists them.
+
+Then it removes the setting. If Memgraph is down, `setup` switches nothing;
+`uninstall` turns the memory back on anyway, with what it held before, and
+warns. Copilot CLI and Grok Build get nothing copied back: their memory is
+hosted by the agent, or kept in folders only it can name.
+
+Codex rewrites its own memory files at each consolidation, so handing back
+leaves each graph memory as an ad-hoc note in
+`~/.codex/memories/extensions/ad_hoc/notes/` (`memories_v2/` under
+`[memories] version = "v2"`), the one place Codex takes outside writes. Its
+next consolidation folds them into `memory_summary.md` and `MEMORY.md`, in its
+own words, so they aren't copied exactly. That runs only while
+`features.memories` and `memories.generate_memories` are on; the output says
+when they weren't before the switch. A note names its project when the memory
+had one, since Codex keeps one store for all projects. Files the import took
+from Codex and the graph never changed aren't noted, and a note already left
+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. 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.
 
 `doctor` fails when the backend is `context-graph` but Claude Code's own memory
 is still on, including when the project's `.claude/settings.json` or

{memgraph_context_graph-0.12.0 → memgraph_context_graph-0.12.2}/docs/research/2026-10-codex-memory.md

@@ -80,6 +80,8 @@ The `[memories]` table (`MemoriesToml`, `config/src/types.rs:322`):
 - `rollout_summaries/<timestamp>-<shorthash>[-<slug>].md`: one recap per selected rollout. Each recap points at the original session `rollout_path`, which is a jsonl file under `~/.codex/sessions/`.
 - `skills/<name>/SKILL.md` (with optional `scripts/`, `examples/`, `templates/`): skills the consolidator promotes.
 - `extensions/ad_hoc/notes/<timestamp>-<slug>.md`: the only place the model may write. It does so only when the user explicitly asks to update memory, and Phase 2 folds the note in later.
+  - The name must be `YYYY-MM-DDTHH-MM-SS-<slug>.md`, with a slug of 1 to 80 lowercase letters, digits and hyphens, and 128 bytes at most. A note is created, never overwritten (`ext/memories/src/local/ad_hoc_note.rs`). Phase 2 is told to treat notes as information, never instructions, to never delete one, and to tag what it derives from them `[ad-hoc note]` (`memories/write/templates/extensions/ad_hoc/instructions.md`). [src]
+  - **Live check, codex-cli 0.162.0, 2026-10-27.** Two notes were written into a throwaway `CODEX_HOME` with memories on. One session's Phase 2 folded both into `memory_summary.md` and `MEMORY.md`, tagged `[ad-hoc note]`. That included a note the first baseline had already committed. The consolidation agent runs in the background of the session that claims the job, and it is shut down with that session: a `codex exec` that ends in seconds kills it (`failed_agent`), and the job then backs off for an hour. [local]
 - `phase2_workspace_diff.md` (transient) and `.git/`: the git baseline that Phase 2 diffs against.
 
 **Injection** [src `ext/memories/src/prompts.rs`, `extension.rs`, `core/src/session/mod.rs`]:

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

@@ -1,6 +1,6 @@
 [project]
 name = "memgraph-context-graph"
-version = "0.12.0"
+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.0 → 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.0 → 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.0 → memgraph_context_graph-0.12.2}/src/memgraph_context_graph/adapters/claude_code_memory.py

@@ -1,8 +1,11 @@
 """Claude Code's auto memory, as Context Graph switches away from and imports it.
 
 Auto memory is Markdown files in ``~/.claude/projects/<project>/memory/``, one
-folder per project. ``<project>`` is the project's absolute path with every
-character other than a letter or digit replaced by ``-``. ``MEMORY.md`` there
+folder per git repository, shared by its worktrees and subdirectories (outside
+a repository, per project folder). ``<project>`` is that folder's absolute path
+with every character other than a letter or digit replaced by ``-``; the other
+``~/.claude/projects/`` folders, one per directory a session started in, hold
+transcripts and are never read for memory. ``MEMORY.md`` there
 is the index Claude Code loads at session start; the other files are
 memories, each with frontmatter naming its ``type``. The ``autoMemoryEnabled``
 setting turns it off; a plugin can't set it, so this edits the user's own
@@ -16,6 +19,7 @@ from __future__ import annotations
 import json
 import re
 import shutil
+import subprocess
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
@@ -23,7 +27,7 @@ from typing import TYPE_CHECKING, Any
 from memgraph_context_graph.memory_backend import ExportReport, ImportReport, MemoryBackendError
 
 if TYPE_CHECKING:
-    from memgraph_context_graph.memory_backend import MemoryFiles, MemorySource, StoredMemory
+    from memgraph_context_graph.memory_backend import MemoryFiles, MemorySource
 
 _SETTING = "autoMemoryEnabled"
 _INDEX_FILE = "MEMORY.md"
@@ -83,8 +87,11 @@ class ClaudeCodeMemory:
         ``user``/``feedback`` memories go under ``/memories/<type>/``, since they
         apply everywhere; ``project``/``reference`` (and untyped) ones under
         that project's ``/memories/projects/<key>/``, keyed as the session-start
-        index keys the checkout. ``MEMORY.md`` is skipped: the index is
-        generated now. The original files are left as they are.
+        index keys the checkout. A ``user``/``feedback`` memory whose name the
+        graph already holds with other text, so another project's own version,
+        goes under its project's folder under its own filename instead, where
+        handing memory back finds it again. ``MEMORY.md`` is skipped: the index
+        is generated now. The original files are left as they are.
         """
         from sessions_graph.memory_index import project_key_for
 
@@ -99,7 +106,11 @@ class ClaudeCodeMemory:
                 if not text.strip():
                     continue
                 target = _target_path(source.name, text, project)
-                if _exists(files, target):
+                lineage = _lineage(files, target)
+                if lineage and text not in lineage and not target.startswith("/memories/projects/"):
+                    target = f"/memories/projects/{project}/{source.name}"
+                    lineage = _lineage(files, target)
+                if lineage:
                     report.skipped.append(target)
                     continue
                 try:
@@ -113,48 +124,87 @@ class ClaudeCodeMemory:
     def export_from(self, source: MemorySource, home: Path) -> ExportReport:
         """Write the graph's memories back into auto memory, the reverse of :meth:`import_into`.
 
-        A project's files go to every Claude Code project folder whose checkout has that key, and
-        ``user``/``feedback`` ones, which apply everywhere, to every folder that ends up with auto memory.
-        The graph's copy wins over an older one here, and each folder's ``MEMORY.md`` is rebuilt. Files
-        Claude Code has no folder for (a project it never opened, nested paths, other agents' files) stay
-        in the graph only.
+        A project's files go to its repository's memory folder. A ``user``/``feedback`` file goes back
+        to the folders it was imported from, which still hold it; one first written in the graph goes
+        to the repositories of the sessions that wrote it. A file there is overwritten only when it is
+        an earlier text of the graph's file, so a newer or unrelated native file is kept and reported.
+        Each folder written to gets its ``MEMORY.md`` rebuilt. Files with no folder to go to (a project
+        Claude Code never opened, nested paths, other agents' files) stay in the graph only.
         """
         folders = _memory_folders(home)
+        every_folder = sorted({folder for found in folders.values() for folder in found})
         report = ExportReport()
-        user_wide: list[tuple[str, StoredMemory]] = []
+        written: set[Path] = set()
         for memory in source.files():
             parts = memory.path.removeprefix("/memories/").split("/")
             if len(parts) == 2 and parts[0] in _USER_WIDE_TYPES:
-                user_wide.append((_native_name(parts[1], memory.content, parts[0]), memory))
-            elif len(parts) == 3 and parts[0] == "projects" and parts[1] in folders:
-                for folder in folders[parts[1]]:
-                    _write_memory(folder, _native_name(parts[2], memory.content, "project"), memory.content)
-                report.exported.append(memory.path)
+                name = _native_name(parts[1], memory.content, parts[0])
+                targets = [folder for folder in every_folder if (folder / name).is_file()] or [
+                    folder for key in source.written_in(memory.path) for folder in folders.get(key, [])
+                ]
+            elif len(parts) == 3 and parts[0] == "projects":
+                name = _native_name(parts[2], memory.content, "project")
+                targets = folders.get(parts[1], [])
             else:
+                targets = []
+            if not targets:
                 report.skipped.append(memory.path)
-        targets = sorted({folder for found in folders.values() for folder in found if folder.is_dir()})
-        for name, memory in user_wide:
+                continue
+            lineage = {memory.content} | {version.content for version in source.versions(memory.path)}
+            kept = []
             for folder in targets:
-                _write_memory(folder, name, memory.content)
-            (report.exported if targets else report.skipped).append(memory.path)
-        for folder in targets:
+                if _write_memory(folder, name, memory.content, lineage):
+                    written.add(folder)
+                elif (folder / name).read_text(encoding="utf-8") != memory.content:
+                    kept.append(str(folder / name))
+            report.kept += kept
+            if len(kept) < len(targets):
+                report.exported.append(memory.path)
+        for folder in sorted(written):
             _write_index(folder)
         return report
 
 
 def _memory_folders(home: Path) -> dict[str, list[Path]]:
-    """Each project key's auto-memory folders: every project Claude Code has opened, keyed as the import keys it."""
+    """Each project key's auto-memory folders, keyed as the import keys them: one per repository Claude Code opened.
+
+    Every ``~/.claude/projects/`` folder whose checkout is in a repository leads to the one folder named after
+    that repository's main checkout, the only one Claude Code reads memory from; a folder whose checkout is
+    gone counts only when it already holds memory.
+    """
     from sessions_graph.memory_index import project_key_for
 
     projects = home / ".claude" / "projects"
-    folders: dict[str, list[Path]] = {}
+    folders: dict[str, set[Path]] = {}
     for project in sorted(projects.iterdir() if projects.is_dir() else []):
         if not project.is_dir():
             continue
         checkout = _checkout_for(project.name)
-        key = (project_key_for(checkout) if checkout else None) or _fallback_key(project.name)
-        folders.setdefault(key, []).append(project / "memory")
-    return folders
+        if checkout is None:
+            if (project / "memory").is_dir():
+                folders.setdefault(_fallback_key(project.name), set()).add(project / "memory")
+            continue
+        root = _repository_root(checkout) or checkout
+        folder = projects / _SLUG_RE.sub("-", str(root)) / "memory"
+        key = project_key_for(checkout) or _fallback_key(folder.parent.name)
+        folders.setdefault(key, set()).add(folder)
+    return {key: sorted(found) for key, found in folders.items()}
+
+
+def _repository_root(checkout: Path) -> Path | None:
+    """The main checkout of the repository *checkout* is in, which its worktrees share; None outside git."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(checkout), "rev-parse", "--path-format=absolute", "--git-common-dir"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    common = Path(result.stdout.strip())
+    return common.parent if result.returncode == 0 and common.name == ".git" else None
 
 
 def _native_name(name: str, text: str, default_type: str) -> str:
@@ -164,12 +214,20 @@ def _native_name(name: str, text: str, default_type: str) -> str:
     return name if _PREFIX_RE.match(name) else f"{memory_type}_{name}"
 
 
-def _write_memory(folder: Path, name: str, text: str) -> None:
+def _write_memory(folder: Path, name: str, text: str, lineage: set[str]) -> bool:
+    """Write *text* to *folder*/*name* unless a file there holds text outside *lineage*; returns whether it wrote.
+
+    *lineage* is the graph file's current and earlier texts. A native file among them is one the graph's copy
+    descends from, so writing over it loses nothing; any other was written beside the graph and is kept.
+    """
     path = folder / name
-    if path.is_file() and path.read_text(encoding="utf-8") == text:
-        return
+    if path.is_file():
+        current = path.read_text(encoding="utf-8")
+        if current == text or current not in lineage:
+            return False
     folder.mkdir(parents=True, exist_ok=True)
     path.write_text(text, encoding="utf-8")
+    return True
 
 
 def _write_index(folder: Path) -> None:
@@ -198,23 +256,39 @@ def _target_path(filename: str, text: str, project: str) -> str:
     return f"/memories/projects/{project}/{name}"
 
 
-def _exists(files: MemoryFiles, path: str) -> bool:
-    try:
-        files.view(path)
-    except Exception:
-        return False
-    return True
+def _lineage(files: MemoryFiles, path: str) -> set[str]:
+    """The graph file at *path*'s current and earlier texts; empty when there is no such file."""
+    current = files.read(path)
+    if current is None:
+        return set()
+    return {current} | {version.content for version in files.versions(path)}
 
 
 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: