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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-memory-git
-Version: 0.1.1
+Version: 0.1.3
 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
@@ -129,11 +131,13 @@ terminal open while you use it. It needs `numpy`; the hooks do not.
 - **Find.** One search box (press `/`). Word matches appear as you type, with the matching words
   marked; a moment later the local model adds memories close in meaning, across Chinese and
   English. Filters narrow the list by type, where a memory loads (everywhere, or one project or
-  folder), which tool wrote it, keyword, age, and whether it needs tidying (what `mem lint`
-  reports, also listed on the open memory); the order is newest, oldest, recently changed or A to Z.
+  folder), which tool wrote it, keyword, when it was added (a recent period or a date range), and
+  status (needs tidying, as `mem lint` reports and the open memory lists, or unchanged for 60
+  days). Tick several values in one filter to see memories that match any of them. The date
+  column's header sets the order: newest, oldest, recently changed or A to Z.
 - **Read.** Click a row, or move with `j`/`k` and press Enter. The memory opens on the right with
-  every frontmatter field (including each `source` entry), the body rendered as Markdown with
-  `[[links]]` that open other memories, the file exactly as stored, and the most similar memories.
+  the body rendered as Markdown with `[[links]]` that open other memories, every frontmatter field
+  (including each `source` entry), the most similar memories, and the file exactly as stored.
 - **Change.** Edit (`e`) or delete from the open memory, add one with New (`n`), or tick several
   rows (`x`) and delete them together. Every change is one git commit, pushed in the background,
   with Undo. If an agent edits the same file meanwhile, saving is refused rather than overwriting.
@@ -157,6 +161,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.3}/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
@@ -109,11 +111,13 @@ terminal open while you use it. It needs `numpy`; the hooks do not.
 - **Find.** One search box (press `/`). Word matches appear as you type, with the matching words
   marked; a moment later the local model adds memories close in meaning, across Chinese and
   English. Filters narrow the list by type, where a memory loads (everywhere, or one project or
-  folder), which tool wrote it, keyword, age, and whether it needs tidying (what `mem lint`
-  reports, also listed on the open memory); the order is newest, oldest, recently changed or A to Z.
+  folder), which tool wrote it, keyword, when it was added (a recent period or a date range), and
+  status (needs tidying, as `mem lint` reports and the open memory lists, or unchanged for 60
+  days). Tick several values in one filter to see memories that match any of them. The date
+  column's header sets the order: newest, oldest, recently changed or A to Z.
 - **Read.** Click a row, or move with `j`/`k` and press Enter. The memory opens on the right with
-  every frontmatter field (including each `source` entry), the body rendered as Markdown with
-  `[[links]]` that open other memories, the file exactly as stored, and the most similar memories.
+  the body rendered as Markdown with `[[links]]` that open other memories, every frontmatter field
+  (including each `source` entry), the most similar memories, and the file exactly as stored.
 - **Change.** Edit (`e`) or delete from the open memory, add one with New (`n`), or tick several
   rows (`x`) and delete them together. Every change is one git commit, pushed in the background,
   with Undo. If an agent edits the same file meanwhile, saving is refused rather than overwriting.
@@ -137,6 +141,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.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agent-memory-git"
-version = "0.1.1"
+version = "0.1.3"
 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.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "agent-memory-git"
-version = "0.1.1"
+version = "0.1.3"
 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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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.3}/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)}