agent-memory-git 0.1.1__tar.gz → 0.1.2__tar.gz

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-memory-git
-Version: 0.1.1
+Version: 0.1.2
 Summary: Shared, git-backed memory for Claude Code and Codex.
 Keywords: claude-code,codex,memory,agents,git
 Author: Shichao Song
@@ -47,6 +47,8 @@ embedding model; leave it out after `mem ui --fetch-model` to also search by mea
 
 ## How it works
 
+![mem install wires hooks into Claude Code and Codex; at session start they load an index from the private data repository, and at the end of each turn they commit and push new memories back](https://raw.githubusercontent.com/Ki-Seki/agent-memory/main/docs/how-it-works.svg)
+
 - **One file per memory.** Frontmatter carries `type` (user / feedback / project / reference),
   `scope` (global / here), a one-line `description`, and provenance under `source`: tool, session
   id and name, model, host, folder, git root, remote, branch and commit. Files live in
@@ -157,6 +159,7 @@ prints, so other web pages cannot read or change memories.
 uv sync --all-extras          # dev tools and numpy
 uv run pytest
 uv run ruff check .
+uv run ruff format .
 ```
 
 `uv run mem ...` runs the working copy without touching the installed one. To have every

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/README.md

@@ -27,6 +27,8 @@ embedding model; leave it out after `mem ui --fetch-model` to also search by mea
 
 ## How it works
 
+![mem install wires hooks into Claude Code and Codex; at session start they load an index from the private data repository, and at the end of each turn they commit and push new memories back](https://raw.githubusercontent.com/Ki-Seki/agent-memory/main/docs/how-it-works.svg)
+
 - **One file per memory.** Frontmatter carries `type` (user / feedback / project / reference),
   `scope` (global / here), a one-line `description`, and provenance under `source`: tool, session
   id and name, model, host, folder, git root, remote, branch and commit. Files live in
@@ -137,6 +139,7 @@ prints, so other web pages cannot read or change memories.
 uv sync --all-extras          # dev tools and numpy
 uv run pytest
 uv run ruff check .
+uv run ruff format .
 ```
 
 `uv run mem ...` runs the working copy without touching the installed one. To have every

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-memory-git"
-version = "0.1.1"
+version = "0.1.2"
 description = "Shared, git-backed memory for Claude Code and Codex."
 readme = "README.md"
 license = "MIT"

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "agent-memory-git"
-version = "0.1.1"
+version = "0.1.2"
 description = "Shared, git-backed memory for Claude Code and Codex."
 readme = "README.md"
 license = "MIT"

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/capture.py

@@ -148,10 +148,10 @@ def stamp_updates(data_dir):
 
 def commit(data_dir, session, label=""):
     stamp_updates(data_dir)
-    title = sessions.title(session.get("tool"), session.get("session_id"),
-                           session.get("transcript_path")) or session.get("session_title", "")
-    stat = gitsync.git(data_dir, "status", "--porcelain", "-uall", "--",
-                       "memories").stdout.splitlines()
+    title = sessions.title(
+        session.get("tool"), session.get("session_id"), session.get("transcript_path")
+    ) or session.get("session_title", "")
+    stat = gitsync.git(data_dir, "status", "--porcelain", "-uall", "--", "memories").stdout.splitlines()
     added = sum(1 for s in stat if s.startswith("??") or s.startswith("A"))
     deleted = sum(1 for s in stat if s[:2].strip() == "D")
     changed = len(stat) - added - deleted

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/cli.py

@@ -74,8 +74,7 @@ def cmd_show(args):
 def cmd_index(args):
     data = _data()
     ctx = detect(args.cwd)
-    paths = {"memories": str(store.memories_dir(data)), "staging": "(per session)",
-             "mem": str(config.BIN)}
+    paths = {"memories": str(store.memories_dir(data)), "staging": "(per session)", "mem": str(config.BIN)}
     text = select.render(store.load_all(data), ctx, paths)
     print(text, end="")
     print(f"\n[{len(text)} characters]", file=sys.stderr)
@@ -88,8 +87,7 @@ def cmd_add(args):
     sdir = store.staging_dir(data) / f"cli-{slugify(args.name)}"
     sdir.mkdir(parents=True, exist_ok=True)
     capture.write_session(sdir, session)
-    meta = {"name": args.name, "type": args.type, "scope": args.scope,
-            "description": args.description}
+    meta = {"name": args.name, "type": args.type, "scope": args.scope, "description": args.description}
     atomic_write(sdir / f"{slugify(args.name)}.md", frontmatter.join(meta, body))
     capture.flush(data, sdir, final=True)
     print("saved")
@@ -107,6 +105,7 @@ def cmd_flush(args):
 def cmd_relocate(args):
     """Re-attribute existing memories recorded in throwaway folders."""
     from . import sessions, workdir
+
     data = _data()
     mdir = store.memories_dir(data)
     moved = 0
@@ -116,8 +115,7 @@ def cmd_relocate(args):
             continue
         if args.only and not any(o in m["rel"] for o in args.only):
             continue
-        transcript = src.get("transcript") or sessions.transcript_path(src.get("tool"),
-                                                                       src.get("session_id"))
+        transcript = src.get("transcript") or sessions.transcript_path(src.get("tool"), src.get("session_id"))
         ctx = capture.relocate({"cwd": src["cwd"], "host": src.get("host")}, transcript)
         if not ctx.get("original_cwd"):
             print(f"keep  {m['rel']}  (no project found)")
@@ -146,12 +144,14 @@ def cmd_relocate(args):
 
 def cmd_lint(args):
     from . import lint
+
     data = _data()
     mdir = store.memories_dir(data)
     memories = store.load_all(data)
     names = {m["name"] for m in memories if m["name"]}
-    picked = [m for m in memories
-              if not args.only or any(k in (m["id"], m["name"]) or k in m["rel"] for k in args.only)]
+    picked = [
+        m for m in memories if not args.only or any(k in (m["id"], m["name"]) or k in m["rel"] for k in args.only)
+    ]
     flagged, kinds = 0, {}
     for m in picked:
         try:
@@ -180,6 +180,7 @@ def cmd_lint(args):
 
 def cmd_ui(args):
     from . import ui, ui_server
+
     if args.fetch_model:
         return ui.fetch_model()
     ui_server.run(_data(), port=args.port, open_browser=not args.no_open, semantic=not args.keywords_only)
@@ -194,26 +195,31 @@ def cmd_sync(args):
 
 def cmd_init(args):
     from .install import init_data
+
     init_data(Path(args.data_dir).expanduser())
 
 
 def cmd_install(args):
     from .install import install
+
     install(dry_run=args.dry_run, claude=not args.no_claude, codex=not args.no_codex)
 
 
 def cmd_uninstall(args):
     from .install import uninstall
+
     uninstall(dry_run=args.dry_run)
 
 
 def cmd_import(args):
     from . import importers
+
     importers.run(args.source, _data(), dry_run=args.dry_run)
 
 
 def cmd_doctor(args):
     from .install import doctor
+
     doctor()
 
 
@@ -277,8 +283,9 @@ def main(argv=None):
     sp.add_argument("--port", type=int, default=8790)
     sp.add_argument("--no-open", action="store_true", help="print the link without opening a browser")
     sp.add_argument("--keywords-only", action="store_true", help="skip the embedding model")
-    sp.add_argument("--fetch-model", action="store_true",
-                    help="download the local embedding model (about 625 MB) and exit")
+    sp.add_argument(
+        "--fetch-model", action="store_true", help="download the local embedding model (about 625 MB) and exit"
+    )
     sp.set_defaults(fn=cmd_ui)
 
     sp = sub.add_parser("sync", help="pull and push the data repository")

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/context.py

@@ -10,8 +10,7 @@ _GIT_ENV = {**os.environ, "GIT_OPTIONAL_LOCKS": "0", "GIT_TERMINAL_PROMPT": "0"}
 
 def _git(cwd, *args):
     try:
-        r = subprocess.run(["git", "-C", cwd, *args], capture_output=True, text=True,
-                           timeout=3, env=_GIT_ENV)
+        r = subprocess.run(["git", "-C", cwd, *args], capture_output=True, text=True, timeout=3, env=_GIT_ENV)
     except (OSError, subprocess.SubprocessError):
         return ""
     return r.stdout.strip() if r.returncode == 0 else ""

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/frontmatter.py

@@ -18,7 +18,7 @@ def split(text):
     for i in range(1, len(lines)):
         if lines[i].strip() == FENCE:
             meta = parse("\n".join(lines[1:i]))
-            body = "\n".join(lines[i + 1:]).lstrip("\n")
+            body = "\n".join(lines[i + 1 :]).lstrip("\n")
             return meta, body
     return {}, text
 
@@ -28,8 +28,7 @@ def join(meta, body):
 
 
 def parse(block):
-    lines = [line.rstrip() for line in block.split("\n")
-             if line.strip() and not line.lstrip().startswith("#")]
+    lines = [line.rstrip() for line in block.split("\n") if line.strip() and not line.lstrip().startswith("#")]
     if not lines:
         return {}
     value, _ = _parse_map(lines, 0, _indent(lines[0]))

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/gitsync.py

@@ -43,8 +43,9 @@ class Lock:
 
 
 def git(data_dir, *args, timeout=30):
-    return subprocess.run(["git", "-C", str(data_dir), *args], capture_output=True,
-                          text=True, timeout=timeout, env=_ENV)
+    return subprocess.run(
+        ["git", "-C", str(data_dir), *args], capture_output=True, text=True, timeout=timeout, env=_ENV
+    )
 
 
 def has_remote(data_dir):
@@ -112,8 +113,13 @@ def spawn_sync(data_dir, push):
     log_path = Path(data_dir) / ".cache" / "sync.out"
     try:
         with open(log_path, "a") as out:
-            subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=out, stderr=out,
-                             start_new_session=True,
-                             env={**os.environ, "AGENT_MEMORY_DATA": str(data_dir)})
+            subprocess.Popen(
+                args,
+                stdin=subprocess.DEVNULL,
+                stdout=out,
+                stderr=out,
+                start_new_session=True,
+                env={**os.environ, "AGENT_MEMORY_DATA": str(data_dir)},
+            )
     except OSError as e:
         log(data_dir, f"spawn sync failed: {e}")

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/hooks.py

@@ -36,14 +36,17 @@ def session_start(payload, tool, data_dir):
     ctx = detect(payload.get("cwd"))
     sdir = capture.session_dir(data_dir, tool, sid)
     sdir.mkdir(parents=True, exist_ok=True)
-    capture.write_session(sdir, {
-        "tool": tool,
-        "session_id": sid,
-        "session_title": payload.get("session_title"),
-        "model": payload.get("model"),
-        "transcript_path": payload.get("transcript_path"),
-        "ctx": ctx,
-    })
+    capture.write_session(
+        sdir,
+        {
+            "tool": tool,
+            "session_id": sid,
+            "session_title": payload.get("session_title"),
+            "model": payload.get("model"),
+            "transcript_path": payload.get("transcript_path"),
+            "ctx": ctx,
+        },
+    )
 
     recovered = capture.recover_orphans(data_dir, keep=sdir)
     stamp = Path(data_dir) / ".cache" / "last-pull"
@@ -59,8 +62,7 @@ def session_start(payload, tool, data_dir):
         "staging": str(sdir),
         "mem": str(config.BIN),
     }
-    return select.render(store.load_all(data_dir), ctx, paths,
-                         throwaway=workdir.is_throwaway(ctx.get("cwd")))
+    return select.render(store.load_all(data_dir), ctx, paths, throwaway=workdir.is_throwaway(ctx.get("cwd")))
 
 
 def flush(payload, tool, data_dir, final):
@@ -82,10 +84,17 @@ def main(event, tool):
     try:
         if event == "session-start":
             text = session_start(payload, tool, data_dir)
-            print(json.dumps({"hookSpecificOutput": {
-                "hookEventName": "SessionStart",
-                "additionalContext": text,
-            }}, ensure_ascii=False))
+            print(
+                json.dumps(
+                    {
+                        "hookSpecificOutput": {
+                            "hookEventName": "SessionStart",
+                            "additionalContext": text,
+                        }
+                    },
+                    ensure_ascii=False,
+                )
+            )
         elif event in ("stop", "session-end"):
             flush(payload, tool, data_dir, final=event == "session-end")
         else:

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/importers.py

@@ -32,14 +32,21 @@ def _git_source(cwd):
 def _record(*, name, typ, scope, description, body, created, source):
     when = parse_time(created) or now()
     memory_id = new_id(name, when)
-    meta = {"id": memory_id, "name": slugify(name), "type": typ, "scope": scope,
-            "description": " ".join(description.split())[:300], "created": when.isoformat(),
-            "source": {k: v for k, v in source.items() if v}}
+    meta = {
+        "id": memory_id,
+        "name": slugify(name),
+        "type": typ,
+        "scope": scope,
+        "description": " ".join(description.split())[:300],
+        "created": when.isoformat(),
+        "source": {k: v for k, v in source.items() if v},
+    }
     return memory_id, meta, body
 
 
 # ---------------------------------------------------------------- Claude Code
 
+
 def _decode_project_dir(name):
     """Recover a folder from Claude's dash-encoded project dir name, if it still exists."""
     tokens = name.lstrip("-").split("-")
@@ -109,15 +116,24 @@ def claude_items():
                     original_cwd, cwd = cwd, inferred
             created = legacy.get("modified") or meta.get("modified") or _mtime(path)
             title = sessions.title("claude-code", origin, transcript) if transcript else ""
-            source = {"tool": "claude-code", "session_id": origin, "session_name": title,
-                      **_git_source(cwd),
-                      "original_cwd": original_cwd,
-                      "imported_from": "claude-code auto memory",
-                      "original": "~/" + path.relative_to(HOME).as_posix()}
-            yield _record(name=m["name"] or path.stem, typ=m["type"],
-                          scope="global" if m["type"] in ("user", "feedback") else "here",
-                          description=m["description"], body=body, created=created,
-                          source=source)
+            source = {
+                "tool": "claude-code",
+                "session_id": origin,
+                "session_name": title,
+                **_git_source(cwd),
+                "original_cwd": original_cwd,
+                "imported_from": "claude-code auto memory",
+                "original": "~/" + path.relative_to(HOME).as_posix(),
+            }
+            yield _record(
+                name=m["name"] or path.stem,
+                typ=m["type"],
+                scope="global" if m["type"] in ("user", "feedback") else "here",
+                description=m["description"],
+                body=body,
+                created=created,
+                source=source,
+            )
 
 
 def _mtime(path):
@@ -126,6 +142,7 @@ def _mtime(path):
 
 # ---------------------------------------------------------------- Codex
 
+
 def _sections(text):
     out, current = {}, None
     for line in text.splitlines():
@@ -158,9 +175,15 @@ def _codex_source(original, cwd=None, thread=None):
         inferred = workdir.infer(rollout, cwd, workdir.default_exclude())
         if inferred:
             original_cwd, cwd = cwd, inferred
-    return {"tool": "codex", "session_id": thread, "session_name": title,
-            **_git_source(cwd), "original_cwd": original_cwd, "imported_from": "codex memories",
-            "original": "~/" + (CODEX_MEMORIES / original).relative_to(HOME).as_posix()}
+    return {
+        "tool": "codex",
+        "session_id": thread,
+        "session_name": title,
+        **_git_source(cwd),
+        "original_cwd": original_cwd,
+        "imported_from": "codex memories",
+        "original": "~/" + (CODEX_MEMORIES / original).relative_to(HOME).as_posix(),
+    }
 
 
 def codex_items():
@@ -171,17 +194,28 @@ def codex_items():
         profile = " ".join(line.strip() for line in sec.get("User Profile", []) if line.strip())
         if profile:
             profile = profile.replace(ADHOC_TAG, "").strip()
-            yield _record(name="user-profile-from-codex", typ="user", scope="global",
-                          description="User profile as summarised by Codex: " + profile[:200],
-                          body=profile + "\n", created=created,
-                          source=_codex_source("memory_summary.md#user-profile"))
+            yield _record(
+                name="user-profile-from-codex",
+                typ="user",
+                scope="global",
+                description="User profile as summarised by Codex: " + profile[:200],
+                body=profile + "\n",
+                created=created,
+                source=_codex_source("memory_summary.md#user-profile"),
+            )
         for heading in ("User preferences", "General Tips"):
             for n, text in enumerate(_bullets(sec.get(heading, []))):
                 if ADHOC_TAG in text or text.startswith("Skills:"):
                     continue  # ad-hoc notes are imported from their own files
-                yield _record(name=" ".join(text.split()[:6]), typ="feedback", scope="global",
-                              description=text, body=text + "\n", created=created,
-                              source=_codex_source(f"memory_summary.md#{slugify(heading)}-{n}"))
+                yield _record(
+                    name=" ".join(text.split()[:6]),
+                    typ="feedback",
+                    scope="global",
+                    description=text,
+                    body=text + "\n",
+                    created=created,
+                    source=_codex_source(f"memory_summary.md#{slugify(heading)}-{n}"),
+                )
 
     handbook = CODEX_MEMORIES / "MEMORY.md"
     if handbook.exists():
@@ -189,27 +223,39 @@ def codex_items():
         for block in blocks:
             if not block.startswith("# Task Group: "):
                 continue
-            title = block.splitlines()[0][len("# Task Group: "):].strip()
+            title = block.splitlines()[0][len("# Task Group: ") :].strip()
             cwd = next(iter(re.findall(r"cwd=([^\s;,)]+)", block)), None)
             thread = next(iter(re.findall(r"thread_id=([0-9a-f-]{36})", block)), None)
             stamps = sorted(re.findall(r"updated_at=([0-9T:.+-]+Z?)", block))
-            yield _record(name=title, typ="project", scope="here",
-                          description=f"Codex task history: {title}", body=block.rstrip() + "\n",
-                          created=stamps[-1] if stamps else _mtime(handbook),
-                          source=_codex_source(f"MEMORY.md#{slugify(title)}", cwd, thread))
+            yield _record(
+                name=title,
+                typ="project",
+                scope="here",
+                description=f"Codex task history: {title}",
+                body=block.rstrip() + "\n",
+                created=stamps[-1] if stamps else _mtime(handbook),
+                source=_codex_source(f"MEMORY.md#{slugify(title)}", cwd, thread),
+            )
 
     for path in sorted((CODEX_MEMORIES / "extensions" / "ad_hoc" / "notes").glob("*.md")):
         body = path.read_text("utf-8")
         _, raw = frontmatter.split(body)
         desc = normalize({}, raw, path.stem)["description"]
         name = re.sub(r"^[0-9T_-]+", "", path.stem) or path.stem
-        yield _record(name=name, typ="reference", scope="global", description=desc, body=raw,
-                      created=_mtime(path),
-                      source=_codex_source(path.relative_to(CODEX_MEMORIES).as_posix()))
+        yield _record(
+            name=name,
+            typ="reference",
+            scope="global",
+            description=desc,
+            body=raw,
+            created=_mtime(path),
+            source=_codex_source(path.relative_to(CODEX_MEMORIES).as_posix()),
+        )
 
 
 # ---------------------------------------------------------------- driver
 
+
 def run(which, data_dir, dry_run=False):
     items = list(claude_items() if which == "claude" else codex_items())
     seen = {m["source"].get("original") for m in load_all(data_dir)}

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/install.py

@@ -33,21 +33,26 @@ SH_BEGIN = "# >>> agent-memory >>>"
 SH_END = "# <<< agent-memory <<<"
 PATH_LINE = 'export PATH="$HOME/.local/bin:$PATH"'
 
-HOOK_EVENTS = [("SessionStart", "session-start", 15),
-               ("Stop", "stop", 15),
-               ("SessionEnd", "session-end", 3)]  # Codex clamps SessionEnd to 3s
+HOOK_EVENTS = [
+    ("SessionStart", "session-start", 15),
+    ("Stop", "stop", 15),
+    ("SessionEnd", "session-end", 3),
+]  # Codex clamps SessionEnd to 3s
 
 
 # ---------------------------------------------------------------- helpers
 
+
 def hook_command(event, tool):
     return " ".join(shlex.quote(a) for a in config.mem_command()) + f" hook {event} --tool {tool}"
 
 
 def _is_ours(group):
-    return any(("agent-memory" in h.get("command", "") or "agent_memory" in h.get("command", ""))
-               and " hook " in h.get("command", "")
-               for h in group.get("hooks", []))
+    return any(
+        ("agent-memory" in h.get("command", "") or "agent_memory" in h.get("command", ""))
+        and " hook " in h.get("command", "")
+        for h in group.get("hooks", [])
+    )
 
 
 def _home_rel(path):
@@ -135,7 +140,7 @@ def toml_unset(text, section, key):
     span = _toml_section("\n".join(lines), section)
     if span:  # drop the section if we emptied it
         i, j = span
-        if all(not line.strip() for line in lines[i + 1:j]):
+        if all(not line.strip() for line in lines[i + 1 : j]):
             del lines[i:j]
     return "\n".join(lines)
 
@@ -149,8 +154,9 @@ def _login_path():
     shell = os.environ.get("SHELL", "/bin/zsh")
     env = {"HOME": str(HOME), "USER": os.environ.get("USER", ""), "SHELL": shell, "TERM": "dumb"}
     try:
-        r = subprocess.run([shell, "-lic", 'printf "__P__%s__P__" "$PATH"'], env=env,
-                           capture_output=True, text=True, timeout=15)
+        r = subprocess.run(
+            [shell, "-lic", 'printf "__P__%s__P__" "$PATH"'], env=env, capture_output=True, text=True, timeout=15
+        )
     except (OSError, subprocess.SubprocessError):
         return None
     m = re.search(r"__P__(.*?)__P__", r.stdout, re.S)
@@ -174,9 +180,10 @@ def _path_plan(plan, state):
 
 # ---------------------------------------------------------------- planning
 
+
 class Plan:
     def __init__(self):
-        self.files = {}          # path -> (old_text or None, new_text or None)
+        self.files = {}  # path -> (old_text or None, new_text or None)
         self.state = {}
 
     def edit(self, path, new_text):
@@ -222,15 +229,22 @@ def _claude_plan(plan, data_dir, state):
     hooks = new.setdefault("hooks", {})
     for event, name, timeout in HOOK_EVENTS:
         groups = [g for g in hooks.get(event, []) if not _is_ours(g)]
-        groups.append({"hooks": [{"type": "command", "command": hook_command(name, "claude-code"),
-                                  "timeout": timeout}]})
+        groups.append(
+            {"hooks": [{"type": "command", "command": hook_command(name, "claude-code"), "timeout": timeout}]}
+        )
         hooks[event] = groups
 
     data = _home_rel(data_dir)
-    rules = [f"Read({data}/**)", f"Edit({data}/**)",
-             f"Bash({config.BIN} search:*)", f"Bash({config.BIN} list:*)",
-             f"Bash({config.BIN} show:*)",
-             "Bash(mem search:*)", "Bash(mem list:*)", "Bash(mem show:*)"]
+    rules = [
+        f"Read({data}/**)",
+        f"Edit({data}/**)",
+        f"Bash({config.BIN} search:*)",
+        f"Bash({config.BIN} list:*)",
+        f"Bash({config.BIN} show:*)",
+        "Bash(mem search:*)",
+        "Bash(mem list:*)",
+        "Bash(mem show:*)",
+    ]
     allow = new.setdefault("permissions", {}).setdefault("allow", [])
     added = [r for r in rules if r not in allow]
     allow.extend(added)
@@ -267,8 +281,10 @@ def _codex_plan(plan, data_dir, state):
         toml = toml_set(toml, "memories", key, "false")
     roots = toml_get(toml, "sandbox_workspace_write", "writable_roots")
     roots = [] if roots == MISSING else list(roots)
-    state.setdefault("codex.writable_roots.had_key", toml_get(
-        _read(toml_path) or "", "sandbox_workspace_write", "writable_roots") != MISSING)
+    state.setdefault(
+        "codex.writable_roots.had_key",
+        toml_get(_read(toml_path) or "", "sandbox_workspace_write", "writable_roots") != MISSING,
+    )
     if str(data_dir) not in roots:
         roots.append(str(data_dir))
         state["codex.writable_root"] = str(data_dir)
@@ -283,6 +299,7 @@ def _codex_plan(plan, data_dir, state):
 
 # ---------------------------------------------------------------- commands
 
+
 def _load_state():
     try:
         return json.loads(STATE_FILE.read_text("utf-8"))
@@ -302,12 +319,15 @@ def init_data(data_dir):
             "# agent-memory data\n\n"
             "One Markdown file per memory under `memories/YYYY/MM/`, written by Claude Code and\n"
             "Codex through the agent-memory hooks. Edit or delete files freely; every change is\n"
-            "a git commit.\n", "utf-8")
+            "a git commit.\n",
+            "utf-8",
+        )
     if not (data_dir / ".git").exists():
         gitsync.git(data_dir, "init", "-q", "-b", "main")
     gitsync.git(data_dir, "add", "-A")
-    gitsync.git(data_dir, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify",
-                "-m", "Initialize memory repository")
+    gitsync.git(
+        data_dir, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify", "-m", "Initialize memory repository"
+    )
     cfg = config.load()
     cfg["data_dir"] = str(data_dir)
     config.save(cfg)
@@ -397,8 +417,11 @@ def uninstall(dry_run=False):
         toml = _read(path) or ""
         for key in ("generate_memories", "use_memories"):
             prev = state.get(f"codex.memories.{key}", MISSING)
-            toml = toml_unset(toml, "memories", key) if prev == MISSING else \
-                toml_set(toml, "memories", key, _toml_literal(prev))
+            toml = (
+                toml_unset(toml, "memories", key)
+                if prev == MISSING
+                else toml_set(toml, "memories", key, _toml_literal(prev))
+            )
         root = state.get("codex.writable_root")
         roots = toml_get(toml, "sandbox_workspace_write", "writable_roots")
         if root and roots != MISSING:
@@ -473,21 +496,30 @@ def doctor():
         check(s.get("autoMemoryEnabled") is False, "Claude auto memory disabled")
         for event, _, _ in HOOK_EVENTS:
             check(any(_is_ours(g) for g in s.get("hooks", {}).get(event, [])), f"Claude {event} hook")
-        check(f"@{config.PROTOCOL_COPY}" in (_read(CLAUDE_DIR / "CLAUDE.md") or ""), "Claude CLAUDE.md imports PROTOCOL.md")
-        check(_read(config.PROTOCOL_COPY) == config.PROTOCOL.read_text("utf-8"),
-              "Claude's PROTOCOL.md copy is current (else run `mem install`)")
+        check(
+            f"@{config.PROTOCOL_COPY}" in (_read(CLAUDE_DIR / "CLAUDE.md") or ""),
+            "Claude CLAUDE.md imports PROTOCOL.md",
+        )
+        check(
+            _read(config.PROTOCOL_COPY) == config.PROTOCOL.read_text("utf-8"),
+            "Claude's PROTOCOL.md copy is current (else run `mem install`)",
+        )
     if state.get("codex"):
         doc = json.loads(_read(CODEX_DIR / "hooks.json") or "{}")
         for event, _, _ in HOOK_EVENTS:
             check(any(_is_ours(g) for g in doc.get("hooks", {}).get(event, [])), f"Codex {event} hook")
         toml = _read(CODEX_DIR / "config.toml") or ""
         check(toml_get(toml, "memories", "use_memories") is False, "Codex native memories disabled")
-        check(config.PROTOCOL.read_text("utf-8").rstrip() in (_read(CODEX_DIR / "AGENTS.md") or ""),
-              "Codex AGENTS.md has the current protocol (else run `mem install`)")
+        check(
+            config.PROTOCOL.read_text("utf-8").rstrip() in (_read(CODEX_DIR / "AGENTS.md") or ""),
+            "Codex AGENTS.md has the current protocol (else run `mem install`)",
+        )
     path = _login_path()
     if path is not None:
-        check(str(LOCAL_BIN.parent) in path or SH_BEGIN in (_read(_rc_file()) or ""),
-              f"`mem` on a new terminal's PATH ({LOCAL_BIN.parent})")
+        check(
+            str(LOCAL_BIN.parent) in path or SH_BEGIN in (_read(_rc_file()) or ""),
+            f"`mem` on a new terminal's PATH ({LOCAL_BIN.parent})",
+        )
     if data:
         check(gitsync.has_remote(data), "data repository has a remote (optional)")
         staged = list((data / "staging").glob("*/*.md")) if (data / "staging").exists() else []

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/lint.py

@@ -6,15 +6,21 @@ someone tidies it, so nothing is rejected.
 
 import re
 
-DESCRIPTION_MAX = 150   # the index cuts longer descriptions (select.line)
+DESCRIPTION_MAX = 150  # the index cuts longer descriptions (select.line)
 BODY_MAX = 1500
 NEEDS_REASON = ("feedback", "project")
 
 _WHY = re.compile(r"\*\*\s*why\s*:?\s*\*\*", re.I)
 _HOW = re.compile(r"\*\*\s*how to apply\s*:?\s*\*\*", re.I)
 _WIKI = re.compile(r"\[\[([^\]]+)\]\]")
-KINDS = {"long": "too long", "reason": "without Why or How to apply", "heading": "opening with a heading",
-         "description": "with a description the index cuts", "links": "with broken links", "empty": "empty"}
+KINDS = {
+    "long": "too long",
+    "reason": "without Why or How to apply",
+    "heading": "opening with a heading",
+    "description": "with a description the index cuts",
+    "links": "with broken links",
+    "empty": "empty",
+}
 
 
 def check(m, body, names):

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/select.py

@@ -72,8 +72,7 @@ def _take(items, budget):
     return out, used
 
 
-THROWAWAY_NOTE = ("throwaway folder: `here` memories will be filed under the project "
-                  "this session works in")
+THROWAWAY_NOTE = "throwaway folder: `here` memories will be filed under the project this session works in"
 
 
 def render(memories, ctx, paths, budget=DEFAULT_BUDGET, throwaway=False):

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/sessions.py

@@ -30,8 +30,7 @@ def _codex_thread(session_id, column):
     try:
         con = sqlite3.connect(f"file:{dbs[-1]}?mode=ro", uri=True, timeout=1)
         try:
-            row = con.execute(f"select {column} from threads where id = ?",
-                              (session_id,)).fetchone()
+            row = con.execute(f"select {column} from threads where id = ?", (session_id,)).fetchone()
         finally:
             con.close()
     except sqlite3.Error:

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/ui.py

@@ -33,23 +33,28 @@ MODEL = {
     "dir": "qwen3-embedding-0.6b-int8",
     "repo": "onnx-community/Qwen3-Embedding-0.6B-ONNX",
     "revision": "c25a394dd583836952667c12f008335071b3f43d",
-    "files": {"onnx/model_quantized.onnx": "87cd124e0ef1fd1f223ebc283efccbaeac386d0b08344701c46975d0657b591f",
-              "config.json": None, "tokenizer.json": None, "tokenizer_config.json": None,
-              "special_tokens_map.json": None},
+    "files": {
+        "onnx/model_quantized.onnx": "87cd124e0ef1fd1f223ebc283efccbaeac386d0b08344701c46975d0657b591f",
+        "config.json": None,
+        "tokenizer.json": None,
+        "tokenizer_config.json": None,
+        "special_tokens_map.json": None,
+    },
     # Plain text, no instruction prefix: on known same-topic pairs (including Chinese/English
     # ones) this ranked partners closer than the topic or similarity instructions did.
     "instruction": "",
 }
 WORKER_DEPS = ["onnxruntime==1.31.0", "tokenizers==0.23.3", "numpy"]
-EMBED_CHARS = 2000        # characters of each memory given to the model
-TITLE_WEIGHT = 3          # description and name count this many times in keyword vectors
-NEIGHBORS = 6             # similar memories listed for each memory
-KEYWORDS = 4              # keywords shown for each memory
+EMBED_CHARS = 2000  # characters of each memory given to the model
+TITLE_WEIGHT = 3  # description and name count this many times in keyword vectors
+NEIGHBORS = 6  # similar memories listed for each memory
+KEYWORDS = 4  # keywords shown for each memory
 SEARCH_INSTRUCTION = "Instruct: Given a search query, retrieve memory notes about it\nQuery: "
 
 _ASCII = re.compile(r"[A-Za-z][A-Za-z0-9_+#-]*[A-Za-z0-9+#]|[A-Za-z]")
 _CJK = re.compile(r"[㐀-鿿]+")
-_STOP = set("""
+_STOP = set(
+    """
 a about above after again against all also am an and any are as at be because been before being
 below between both but by can could did do does doing done down during each either else etc even
 ever every few for from further get gets got had has have having he her here hers him his how i if
@@ -67,21 +72,28 @@ rollout_summary_files rollout_summaries applies_to reuse_rule keywords reusable
 differently preferences apply how why outcome success partial history summary
 asked plus real never check checks verify verified evidence explicit said complete final current
 live state local source remote text path test symptom instead before after already actual ad-hoc
-""".split())
+""".split()
+)
 # Paths, URLs, hashes and ids say where something lives, not what it is about.
-_NOISE = re.compile(r"(?:https?://\S+|(?:~|/|\.\.?/)[\w.@%+-]+(?:/[\w.@%+-]*)+"
-                    r"|\b[\w.-]+\.(?:md|json|jsonl|py|ts|js|html|yaml|yml|toml|txt|sh)\b"
-                    r"|\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b|\b[0-9a-f]{7,40}\b"
-                    r"|\b\d{4}-\d\d-\d\d(?:[T ][\d:.+-]+)?\b)")
+_NOISE = re.compile(
+    r"(?:https?://\S+|(?:~|/|\.\.?/)[\w.@%+-]+(?:/[\w.@%+-]*)+"
+    r"|\b[\w.-]+\.(?:md|json|jsonl|py|ts|js|html|yaml|yml|toml|txt|sh)\b"
+    r"|\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b|\b[0-9a-f]{7,40}\b"
+    r"|\b\d{4}-\d\d-\d\d(?:[T ][\d:.+-]+)?\b)"
+)
 CJK_MAX = 4
-_STOP_CJK = set("""
+_STOP_CJK = set(
+    """
 的是 是的 一个 这个 那个 可以 需要 如果 因为 所以 但是 而且 或者 以及 我们 你们 他们 用户 时候 没有 不是 就是
 已经 进行 通过 使用 这样 这些 那些 什么 怎么 为了 之后 之前 然后 还是 一下 一些 这里 那里 其中 以后 以前 不要
 必须 应该 能够 只是 也是 都是 就会 会在 在这 这次 每次 一次 当前 目前 现在 之类 等等 方面 问题 内容 情况
 相关 进行 这种 时候 需要 不能 不会 只有 直接 所有 其他 自己 一样 部分 以上 以下 下来 起来 出来 每个 各个 任何 一定 先给
-""".split())
+""".split()
+)
 # Function characters that start no word: 的了和与… A string beginning with one is a fragment.
-_CJK_BAD_START = set("的了和与及或就都也把被让给并而时在是对向从个件等上不每一这那该各再又还才只很最更已将会能要可使于以之其此")
+_CJK_BAD_START = set(
+    "的了和与及或就都也把被让给并而时在是对向从个件等上不每一这那该各再又还才只很最更已将会能要可使于以之其此"
+)
 _CJK_KEEP = {"完成", "生成", "集成", "构成", "组成", "前后", "最后", "然后", "之后", "背后", "上一", "中文"}
 # ...and characters that end no word: a string ending in one runs into the next word.
 _CJK_BAD_END = set("的了着过是在和与及等上中里成到给把被让后不也都就又再才很一个这那各每将会能要可于以之其此任")
@@ -89,6 +101,7 @@ _CJK_BAD_END = set("的了着过是在和与及等上中里成到给把被让后
 
 # ------------------------------------------------------------ keyword vectors
 
+
 def clean(text):
     return _NOISE.sub(" ", text)
 
@@ -105,7 +118,7 @@ def chinese_words(texts):
         grams = set()
         for run in _CJK.findall(text):
             for n in range(2, CJK_MAX + 1):
-                grams.update(run[i:i + n] for i in range(len(run) - n + 1))
+                grams.update(run[i : i + n] for i in range(len(run) - n + 1))
         df.update(grams)
     frequent = {g for g, d in df.items() if d >= 2}
     words = set()
@@ -113,8 +126,11 @@ def chinese_words(texts):
         longer = [h for h in frequent if len(h) == len(g) + 1 and g in h]
         if not any(df[h] >= 0.8 * df[g] for h in longer):
             words.add(g)
-    return {w for w in words - _STOP_CJK
-            if (w[0] not in _CJK_BAD_START or w == "时间") and (w[-1] not in _CJK_BAD_END or w in _CJK_KEEP)}
+    return {
+        w
+        for w in words - _STOP_CJK
+        if (w[0] not in _CJK_BAD_START or w == "时间") and (w[-1] not in _CJK_BAD_END or w in _CJK_KEEP)
+    }
 
 
 def tokens(text, words=frozenset()):
@@ -136,8 +152,8 @@ def tokens(text, words=frozenset()):
         i = 0
         while i < len(run) - 1:
             for n in range(min(CJK_MAX, len(run) - i), 1, -1):
-                if run[i:i + n] in words:
-                    out.append(run[i:i + n])
+                if run[i : i + n] in words:
+                    out.append(run[i : i + n])
                     i += n
                     break
             else:
@@ -155,7 +171,8 @@ def _display_forms(texts):
 
 
 # Plain English words that score high in TF-IDF but say little about what a memory is about.
-_GENERIC = set("""
+_GENERIC = set(
+    """
 actually specified large small nontrivial declaring declared truth human builds build built pin pinned
 following follow follows needed need needs means mean simple simply clear clearly important exact exactly
 whole entire full fully main mainly certain directly direct proper properly various several general
@@ -163,7 +180,8 @@ correct correctly wrong instead later earlier often usually rather quite really
 item items part parts kind way ways case cases point points detail details thing result results
 come comes edit edits edited anything something everything separate change changes changed
 fail fails failed code example examples
-""".split())
+""".split()
+)
 
 
 def _term_like(display):
@@ -271,13 +289,21 @@ def embed(data_dir, texts):
     if todo:
         out = cache_file.with_name("new-vectors.npy")
         out.parent.mkdir(parents=True, exist_ok=True)
-        job = {"model_dir": str(model_dir()), "out": str(out), "max_tokens": 512,
-               "texts": [MODEL["instruction"] + texts[i] for i in todo]}
+        job = {
+            "model_dir": str(model_dir()),
+            "out": str(out),
+            "max_tokens": 512,
+            "texts": [MODEL["instruction"] + texts[i] for i in todo],
+        }
         print(f"embedding {len(todo)} memories with {MODEL['name']}…", flush=True)
-        cmd = ["uv", "run", "--no-project", "--quiet"] + [a for dep in WORKER_DEPS for a in ("--with", dep)] \
+        cmd = (
+            ["uv", "run", "--no-project", "--quiet"]
+            + [a for dep in WORKER_DEPS for a in ("--with", dep)]
             + ["python", "-I", str(WORKER)]
-        r = subprocess.run(cmd, input=json.dumps(job), text=True, cwd=str(out.parent),
-                           env={**os.environ, "PYTHONWARNINGS": "ignore"})
+        )
+        r = subprocess.run(
+            cmd, input=json.dumps(job), text=True, cwd=str(out.parent), env={**os.environ, "PYTHONWARNINGS": "ignore"}
+        )
         if r.returncode != 0:
             print("embedding failed; falling back to keywords", file=sys.stderr)
             return None
@@ -307,9 +333,10 @@ def closeness(vectors):
 
 # ------------------------------------------------------------ page data
 
+
 def _short(path):
     home = str(HOME)
-    return "~" + path[len(home):] if path and (path == home or path.startswith(home + "/")) else path or ""
+    return "~" + path[len(home) :] if path and (path == home or path.startswith(home + "/")) else path or ""
 
 
 def _place(src):
@@ -355,31 +382,52 @@ def build(data_dir, semantic=True, vectors_out=None):
     for i, (m, raw, meta, body) in enumerate(items):
         order = [int(j) for j in np.argsort(-sim[i]) if j != i][:NEIGHBORS]
         src = m["source"]
-        rows.append({
-            "id": m["id"], "rel": m["rel"], "path": str(mdir / m["rel"]),
-            "hash": hashlib.sha1(raw.encode()).hexdigest()[:16], "raw": raw,
-            "meta": json.loads(json.dumps(meta, default=str)), "body": body,
-            "description": m["description"], "type": m["type"], "scope": m["scope"],
-            "place": _place(src) if m["scope"] == "here" else "",
-            "tool": src.get("tool") or "", "host": src.get("host") or "",
-            "created": m["created"], "updated": m["updated"],
-            "similar": [{"i": j, "s": round(float(sim[i, j]), 3)} for j in order if sim[i, j] > 0],
-            "keywords": [{"k": vocab[j], "t": forms.get(vocab[j], vocab[j])} for j in picks[i]],
-            "terms": [vocab[j] for j in np.flatnonzero(x[i])],
-            "issues": [message for _, message in lint.check(m, body, names)],
-        })
+        rows.append(
+            {
+                "id": m["id"],
+                "rel": m["rel"],
+                "path": str(mdir / m["rel"]),
+                "hash": hashlib.sha1(raw.encode()).hexdigest()[:16],
+                "raw": raw,
+                "meta": json.loads(json.dumps(meta, default=str)),
+                "body": body,
+                "description": m["description"],
+                "type": m["type"],
+                "scope": m["scope"],
+                "place": _place(src) if m["scope"] == "here" else "",
+                "tool": src.get("tool") or "",
+                "host": src.get("host") or "",
+                "created": m["created"],
+                "updated": m["updated"],
+                "similar": [{"i": j, "s": round(float(sim[i, j]), 3)} for j in order if sim[i, j] > 0],
+                "keywords": [{"k": vocab[j], "t": forms.get(vocab[j], vocab[j])} for j in picks[i]],
+                "terms": [vocab[j] for j in np.flatnonzero(x[i])],
+                "issues": [message for _, message in lint.check(m, body, names)],
+            }
+        )
         if m["scope"] == "here" and (src.get("git_remote") or src.get("cwd")):
             key = _place(src)
-            places.setdefault(key, {"key": key, "count": 0,
-                                    "ctx": {k: src[k] for k in ("cwd", "git_root", "git_remote", "git_branch", "host")
-                                            if src.get(k)}})
+            places.setdefault(
+                key,
+                {
+                    "key": key,
+                    "count": 0,
+                    "ctx": {k: src[k] for k in ("cwd", "git_root", "git_remote", "git_branch", "host") if src.get(k)},
+                },
+            )
             places[key]["count"] += 1
-    return {**base, "memories": rows, "method": method, "semantic": vectors is not None,
-            "places": sorted(places.values(), key=lambda p: (-p["count"], p["key"]))}
+    return {
+        **base,
+        "memories": rows,
+        "method": method,
+        "semantic": vectors is not None,
+        "places": sorted(places.values(), key=lambda p: (-p["count"], p["key"])),
+    }
 
 
 # ------------------------------------------------------------ query embedding
 
+
 class QueryEncoder:
     """A long-lived embedding worker for search queries (model loads once)."""
 
@@ -392,12 +440,20 @@ class QueryEncoder:
             return None
         with self.lock:
             if self.proc is None or self.proc.poll() is not None:
-                cmd = ["uv", "run", "--no-project", "--quiet"] + \
-                    [a for dep in WORKER_DEPS for a in ("--with", dep)] + \
-                    ["python", "-I", str(WORKER), "--serve", str(model_dir())]
-                self.proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                                             stderr=subprocess.DEVNULL, text=True, bufsize=1,
-                                             cwd=str(model_dir()))
+                cmd = (
+                    ["uv", "run", "--no-project", "--quiet"]
+                    + [a for dep in WORKER_DEPS for a in ("--with", dep)]
+                    + ["python", "-I", str(WORKER), "--serve", str(model_dir())]
+                )
+                self.proc = subprocess.Popen(
+                    cmd,
+                    stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.DEVNULL,
+                    text=True,
+                    bufsize=1,
+                    cwd=str(model_dir()),
+                )
             self.proc.stdin.write(json.dumps({"text": SEARCH_INSTRUCTION + text}) + "\n")
             self.proc.stdin.flush()
             line = self.proc.stdout.readline()

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/ui_server.py

@@ -26,10 +26,11 @@ from .context import detect, hostname
 from .util import SCOPES, TYPES, atomic_write, id_path, log_exc, new_id, now_iso, slugify
 
 STATIC = Path(__file__).with_name("webui")
-MIME = {".html": "text/html; charset=utf-8", ".css": "text/css; charset=utf-8",
-        ".js": "text/javascript; charset=utf-8"}
-CSP = ("default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; "
-       "connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'")
+MIME = {".html": "text/html; charset=utf-8", ".css": "text/css; charset=utf-8", ".js": "text/javascript; charset=utf-8"}
+CSP = (
+    "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; "
+    "connect-src 'self'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'"
+)
 PLACE_FIELDS = ("cwd", "git_root", "git_remote", "git_branch")
 SEARCH_HITS = 8
 
@@ -94,8 +95,7 @@ class UiApp:
         scores = self.vectors @ vec
         order = np.argsort(-scores)[:SEARCH_HITS]
         ids = [self.state["memories"][int(i)]["id"] for i in order]
-        return {"hits": [{"id": mid, "s": round(float(scores[i]), 3)} for mid, i in zip(ids, order)],
-                "semantic": True}
+        return {"hits": [{"id": mid, "s": round(float(scores[i]), 3)} for mid, i in zip(ids, order)], "semantic": True}
 
     # ------------------------------------------------------------ writes
 
@@ -109,8 +109,11 @@ class UiApp:
         path = self.mdir / self._find(mid)["rel"]
         text = path.read_text("utf-8")
         if base and hashlib.sha1(text.encode()).hexdigest()[:16] != base:
-            raise ApiError(409, "This memory changed on disk after you opened it (an agent may have "
-                                "edited it). Close it and open it again to see the new version.")
+            raise ApiError(
+                409,
+                "This memory changed on disk after you opened it (an agent may have "
+                "edited it). Close it and open it again to see the new version.",
+            )
         meta, body = frontmatter.split(text)
         return path, meta, body
 
@@ -129,8 +132,18 @@ class UiApp:
     def _commit(self, paths, message):
         rels = [str(Path(p).relative_to(self.data)) for p in ([paths] if isinstance(paths, (str, Path)) else paths)]
         gitsync.git(self.data, "add", "-A", "--", *rels)
-        r = gitsync.git(self.data, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify",
-                        "-m", message + "\n\nTool: ui", "--", *rels)
+        r = gitsync.git(
+            self.data,
+            "-c",
+            "commit.gpgsign=false",
+            "commit",
+            "-q",
+            "--no-verify",
+            "-m",
+            message + "\n\nTool: ui",
+            "--",
+            *rels,
+        )
         if r.returncode != 0:
             if "nothing" in r.stdout + r.stderr:
                 return None
@@ -203,13 +216,21 @@ class UiApp:
             source.update({k: ctx[k] for k in PLACE_FIELDS if ctx.get(k)})
         name = slugify(p.get("name") or desc)
         mid = new_id(name)
-        meta = {"id": mid, "name": name, "type": typ, "scope": scope, "description": desc,
-                "created": now_iso(), "source": source}
+        meta = {
+            "id": mid,
+            "name": name,
+            "type": typ,
+            "scope": scope,
+            "description": desc,
+            "created": now_iso(),
+            "source": source,
+        }
         path = self.mdir / id_path(mid)
 
         def write():
             atomic_write(path, frontmatter.join(meta, str(p.get("body", ""))))
             return {"id": mid, "commit": self._commit(path, f"memory: add {mid} (ui)")}
+
         return self._write(write)
 
     def edit(self, p):
@@ -219,8 +240,11 @@ class UiApp:
             if not changed:
                 return {"id": p.get("id"), "commit": None}
             atomic_write(path, frontmatter.join(meta, new_body))
-            return {"id": p.get("id"),
-                    "commit": self._commit(path, f"memory: edit {p.get('id')} ({', '.join(changed)}) (ui)")}
+            return {
+                "id": p.get("id"),
+                "commit": self._commit(path, f"memory: edit {p.get('id')} ({', '.join(changed)}) (ui)"),
+            }
+
         return self._write(write)
 
     def delete(self, p):
@@ -237,8 +261,10 @@ class UiApp:
                 message = f"memory: delete {items[0].get('id')} (ui)\n\n{loaded[0][1].get('description', '')}"
             else:
                 message = f"memory: delete {len(loaded)} memories (ui)\n\n" + "\n".join(
-                    f"- {it.get('id')}: {meta.get('description', '')}" for it, (_, meta, _) in zip(items, loaded))
+                    f"- {it.get('id')}: {meta.get('description', '')}" for it, (_, meta, _) in zip(items, loaded)
+                )
             return {"commit": self._commit([path for path, _, _ in loaded], message)}
+
         return self._write(write)
 
     def undo(self, p):
@@ -254,11 +280,21 @@ class UiApp:
             if r.returncode != 0:
                 gitsync.git(self.data, "revert", "--abort")
                 raise ApiError(409, "Could not undo: that memory changed again since. Edit it instead.")
-            gitsync.git(self.data, "-c", "commit.gpgsign=false", "commit", "-q", "--no-verify",
-                        "-m", f"memory: undo {rev} (ui)\n\nTool: ui", timeout=10)
+            gitsync.git(
+                self.data,
+                "-c",
+                "commit.gpgsign=false",
+                "commit",
+                "-q",
+                "--no-verify",
+                "-m",
+                f"memory: undo {rev} (ui)\n\nTool: ui",
+                timeout=10,
+            )
             if gitsync.has_remote(self.data):
                 gitsync.spawn_sync(self.data, push=True)
             return {"ok": True}
+
         return self._write(write)
 
 
@@ -272,8 +308,13 @@ class Handler(BaseHTTPRequestHandler):
     def _send(self, status, payload, ctype="application/json; charset=utf-8"):
         body = payload if isinstance(payload, bytes) else json.dumps(payload, ensure_ascii=False).encode()
         self.send_response(status)
-        for k, v in (("Content-Type", ctype), ("Content-Length", str(len(body))), ("Cache-Control", "no-store"),
-                     ("X-Content-Type-Options", "nosniff"), ("Referrer-Policy", "no-referrer")):
+        for k, v in (
+            ("Content-Type", ctype),
+            ("Content-Length", str(len(body))),
+            ("Cache-Control", "no-store"),
+            ("X-Content-Type-Options", "nosniff"),
+            ("Referrer-Policy", "no-referrer"),
+        ):
             self.send_header(k, v)
         if ctype.startswith("text/html"):
             self.send_header("Content-Security-Policy", CSP)
@@ -316,8 +357,11 @@ class Handler(BaseHTTPRequestHandler):
                 return self._send(404, {"error": "not found"})
             return self._send(200, path.read_bytes(), MIME[path.suffix])
         app, q = self.server.app, {k: v[0] for k, v in parse_qs(url.query).items()}
-        routes = {"/api/state": app.current, "/api/stamp": lambda: {"stamp": app.stamp()},
-                  "/api/search": lambda: app.search(q.get("q"))}
+        routes = {
+            "/api/state": app.current,
+            "/api/stamp": lambda: {"stamp": app.stamp()},
+            "/api/search": lambda: app.search(q.get("q")),
+        }
         if url.path not in routes:
             return self._send(404, {"error": "not found"})
         self._run(routes[url.path])
@@ -353,8 +397,11 @@ def make_server(data_dir, port=8790, semantic=True):
 
 def run(data_dir, port=8790, open_browser=True, semantic=True):
     if semantic and not ui.model_ready():
-        print("No local embedding model; similar memories use keywords only. "
-              "Run `mem ui --fetch-model` (about 625 MB) to also search by meaning.", flush=True)
+        print(
+            "No local embedding model; similar memories use keywords only. "
+            "Run `mem ui --fetch-model` (about 625 MB) to also search by meaning.",
+            flush=True,
+        )
     server = make_server(data_dir, port, semantic)
     print(f"Memories: {server.url}", flush=True)
     print("Keep this terminal open while you use it; Ctrl+C stops it.", flush=True)

{agent_memory_git-0.1.1 → agent_memory_git-0.1.2}/src/agent_memory/workdir.py

@@ -15,13 +15,15 @@ from . import config
 from .util import HOME, is_under
 
 DEFAULT_THROWAWAY = [
-    r"/scratch-workspaces/",                          # Claude Code, no folder chosen
-    r"^~/Documents/Codex/\d{4}-\d{2}-\d{2}/[^/]+",    # Codex desktop, one folder per thread
+    r"/scratch-workspaces/",  # Claude Code, no folder chosen
+    r"^~/Documents/Codex/\d{4}-\d{2}-\d{2}/[^/]+",  # Codex desktop, one folder per thread
 ]
 # Folders that only hold other folders; never the answer on their own.
-CONTAINERS = re.compile(r"^(Library/CloudStorage(/[^/]+)?|Library/Application Support|"
-                        r"Library/Mobile Documents|Documents|Documents/Codex|"
-                        r"Documents/Codex/\d{4}-\d{2}-\d{2}|Desktop|Downloads)$")
+CONTAINERS = re.compile(
+    r"^(Library/CloudStorage(/[^/]+)?|Library/Application Support|"
+    r"Library/Mobile Documents|Documents|Documents/Codex|"
+    r"Documents/Codex/\d{4}-\d{2}-\d{2}|Desktop|Downloads)$"
+)
 TAIL_BYTES = 8 * 1024 * 1024  # new memories are about recent work
 MIN_HITS = 3
 DESCEND_SHARE = 0.6
@@ -108,8 +110,9 @@ def infer(transcript, cwd=None, exclude=(), home=None):
     def descend(n, best):
         limit = MAX_DEPTH + (2 if best[0] == "Library" else 0)  # ~/Library/CloudStorage/<drive>/...
         while len(best) < limit and not home.joinpath(*best, ".git").exists():
-            kids = [(c, k) for k, c in counts.items()
-                    if len(k) == len(best) + 1 and k[:len(best)] == best and usable(k)]
+            kids = [
+                (c, k) for k, c in counts.items() if len(k) == len(best) + 1 and k[: len(best)] == best and usable(k)
+            ]
             if not kids:
                 break
             c, k = max(kids)