agent-memory-cli 0.1.0__tar.gz → 0.1.1__tar.gz

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to agent-memory are documented in this file. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.1.1 - 2026-09-12
+
+### Added
+
+- `event write` publishes one org-memory event under `org-memory/events/`, never replacing a published record ([event](docs/commands.md#event-write)).
+- A `v*` tag attaches the built sdist and wheel to the GitHub Release ([releases](https://github.com/kiloloop/agent-memory/releases)).
+
+### Fixed
+
+- A nested `.gitignore` or `.oacp-memory-repo` no longer blocks `pull`; the allowlist anchors both names to the home root ([sync](docs/commands.md#sync)).
+- `enable` retires superseded lines when it updates a home's `.gitignore`, and the receipt names them ([sync](docs/commands.md#sync)).
+- `doctor` scopes its working-tree row to the allowlist: memory changes read DIRTY, and changes elsewhere are named as outside it ([doctor](docs/commands.md#doctor)).
+- `push` and `doctor` keep both paths of a rename git detects in the working tree; the source path was previously misread ([sync](docs/commands.md#sync)).
+- `push` names a credential helper a sandbox blocked as its own failure, with the remedy, instead of reporting it as a rejected push ([sync](docs/commands.md#sync)).
+
 ## 0.1.0 - 2026-09-06
 
 ### Added

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agent-memory-cli
-Version: 0.1.0
+Version: 0.1.1
 Summary: Cross-session memory for coding agents: plain files, git-native, no server
 Project-URL: Homepage, https://github.com/kiloloop/agent-memory
 Project-URL: Source, https://github.com/kiloloop/agent-memory
@@ -24,7 +24,7 @@ Requires-Python: >=3.10
 Provides-Extra: dev
 Requires-Dist: build<2,>=1.2; extra == 'dev'
 Requires-Dist: pytest<10,>=8; extra == 'dev'
-Requires-Dist: ruff<1,>=0.11; extra == 'dev'
+Requires-Dist: ruff<0.17,>=0.16; extra == 'dev'
 Requires-Dist: twine<8,>=7; extra == 'dev'
 Description-Content-Type: text/markdown
 
@@ -177,6 +177,7 @@ similarity queries, synthesis, or indexing. Recall reads a fixed file set.
 | [`capture`][capture-and-recall] | Record a decision. |
 | [`recall`][capture-and-recall] | Read bounded context. |
 | [`debrief write`][debrief-write] | Publish a session summary. |
+| [`event write`][event-write] | Publish an org-memory event. |
 
 [status]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#status
 [doctor]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#doctor
@@ -187,6 +188,7 @@ similarity queries, synthesis, or indexing. Recall reads a fixed file set.
 [startup]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#startup
 [capture-and-recall]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#capture-and-recall
 [debrief-write]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#debrief-write
+[event-write]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#event-write
 
 ## Examples
 

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/README.md

@@ -147,6 +147,7 @@ similarity queries, synthesis, or indexing. Recall reads a fixed file set.
 | [`capture`][capture-and-recall] | Record a decision. |
 | [`recall`][capture-and-recall] | Read bounded context. |
 | [`debrief write`][debrief-write] | Publish a session summary. |
+| [`event write`][event-write] | Publish an org-memory event. |
 
 [status]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#status
 [doctor]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#doctor
@@ -157,6 +158,7 @@ similarity queries, synthesis, or indexing. Recall reads a fixed file set.
 [startup]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#startup
 [capture-and-recall]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#capture-and-recall
 [debrief-write]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#debrief-write
+[event-write]: https://github.com/kiloloop/agent-memory/blob/main/docs/commands.md#event-write
 
 ## Examples
 

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/pyproject.toml

@@ -38,7 +38,7 @@ Changelog = "https://github.com/kiloloop/agent-memory/blob/main/CHANGELOG.md"
 dev = [
   "build>=1.2,<2",
   "pytest>=8,<10",
-  "ruff>=0.11,<1",
+  "ruff>=0.16,<0.17",
   "twine>=7,<8",
 ]
 

agent_memory_cli-0.1.1/scripts/release_notes.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: 2026 Kiloloop
+# SPDX-License-Identifier: Apache-2.0
+"""Print the changelog section for one release, as GitHub Release notes.
+
+The release workflow feeds this to ``gh release create --notes-file``. GitHub's own
+``--generate-notes`` cannot serve here: the public repository receives each version as a
+single squashed commit, so the generated summary is one line no matter how much the
+release contains. The changelog section already says what shipped, one line per change.
+
+Two transformations make a changelog section stand alone on a release page:
+
+1. Relative links (``docs/commands.md#init``) are rewritten against the tag. A release
+   body is not rendered relative to the repository root, so a relative target 404s; and
+   pinning to the tag rather than to ``main`` keeps old release notes pointing at the
+   documentation as it stood for that version.
+2. The section heading itself is dropped — the release already carries the version.
+
+Exits 1 when the section is absent, so the caller can fall back rather than publish a
+release with an empty body.
+"""
+
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+LINK = re.compile(r"\]\(([^)]+)\)")
+
+
+def extract(changelog: str, version: str) -> str | None:
+    """Return the body of ``## <version>``, or None when no such section exists."""
+    lines = changelog.split("\n")
+    start = None
+    for i, line in enumerate(lines):
+        # "## 0.1.0 - 2026-09-06" and "## [0.1.0] - ..." both name this version.
+        if line.startswith("## ") and re.match(rf"##\s+\[?{re.escape(version)}\]?\b", line):
+            start = i + 1
+            break
+    if start is None:
+        return None
+    body: list[str] = []
+    for line in lines[start:]:
+        if line.startswith("## "):
+            break
+        body.append(line)
+    return "\n".join(body).strip() or None
+
+
+def absolutise(notes: str, repository: str, tag: str) -> str:
+    """Rewrite repo-relative link targets to absolute URLs pinned at ``tag``."""
+    base = f"https://github.com/{repository}/blob/{tag}/"
+    return LINK.sub(
+        lambda m: f"]({m.group(1)})" if m.group(1).startswith("http") else f"]({base}{m.group(1)})",
+        notes,
+    )
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--tag", required=True, help="release tag, e.g. v0.1.0")
+    parser.add_argument("--repository", required=True, help="owner/repo, for absolute links")
+    parser.add_argument("--changelog", default="CHANGELOG.md", type=Path)
+    args = parser.parse_args()
+
+    version = args.tag[1:] if args.tag.startswith("v") else args.tag
+    notes = extract(args.changelog.read_text(encoding="utf-8"), version)
+    if notes is None:
+        print(f"no changelog section for {version} in {args.changelog}", file=sys.stderr)
+        return 1
+    print(absolutise(notes, args.repository, args.tag))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/src/agent_memory/__init__.py

@@ -4,6 +4,6 @@
 
 from .home import HomeError, HomeResolution, resolve_home
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 __all__ = ["HomeError", "HomeResolution", "__version__", "resolve_home"]

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/src/agent_memory/cli.py

@@ -10,7 +10,7 @@ import sys
 from pathlib import Path
 from typing import Callable, List, Optional, Sequence, Tuple
 
-from . import __version__, archive, debrief, doctor, org, setup, startup, status, sync, workflow
+from . import __version__, archive, debrief, doctor, events, org, setup, startup, status, sync, workflow
 from .home import BINDING_FILE, HomeError, HomeResolution, find_project, resolve_home
 
 EXIT_OK = 0
@@ -189,6 +189,38 @@ def build_parser() -> argparse.ArgumentParser:
     write.add_argument("--oacp-dir", dest="home", metavar="PATH", help=argparse.SUPPRESS)
     write.add_argument("--dry-run", action="store_true", help="validate and compose the record, print it, and write nothing")
     write.add_argument("--json", dest="json_output", action="store_true", help="emit a machine-readable result")
+    event_ = commands.add_parser("event", help="Org-memory event commands.", description="Org-memory event commands.")
+    event_commands = event_.add_subparsers(dest="event_command", metavar="<command>")
+    event_help = (
+        "Publish one org-memory event into the home's events store, failure-atomically: the canonical path only ever "
+        "holds a complete, verified record, byte-identical to the kernel's write-event script for the same inputs. "
+        "Exit 0 published (or an identical record was already there), 1 on a validation error, 2 on a publication "
+        "failure."
+    )
+    event_write = event_commands.add_parser("write", parents=[common], help=event_help, description=event_help)
+    event_write.set_defaults(handler=_event_write)
+    event_write.add_argument("--agent", required=True, help="agent creating the event")
+    event_write.add_argument("--project", required=True, help="originating project")
+    event_write.add_argument(
+        "--type", dest="event_type", required=True, choices=sorted(events.ALLOWED_TYPES), help="event type"
+    )
+    event_write.add_argument(
+        "--slug", required=True, help="short slug for the filename: lowercase alphanumerics and hyphens, no dots"
+    )
+    event_body = event_write.add_mutually_exclusive_group()
+    event_body.add_argument("--body", help="event body, inline")
+    event_body.add_argument("--body-file", help="path to the event body in Markdown, or '-' to read stdin")
+    event_write.add_argument("--source-ref", help="provenance id, e.g. the debrief stem the event was folded from")
+    event_write.add_argument(
+        "--related", help="cross-references: comma-separated or a JSON array (e.g. 'PR #43,issue #10')"
+    )
+    event_write.add_argument("--supersedes", help="path of the event this entry overrides")
+    # The kernel script's home flag; accepted, unadvertised, through v0.1.x.
+    event_write.add_argument("--oacp-dir", dest="home", metavar="PATH", help=argparse.SUPPRESS)
+    event_write.add_argument(
+        "--dry-run", action="store_true", help="validate and compose the record, print it, and write nothing"
+    )
+    event_write.add_argument("--json", dest="json_output", action="store_true", help="emit a machine-readable result")
     return parser
 
 
@@ -414,6 +446,85 @@ def _debrief_write(args: argparse.Namespace) -> int:
     return EXIT_OK
 
 
+def _event_write(args: argparse.Namespace) -> int:
+    home = resolve_home(args.home).path
+    try:
+        body = _event_body(args)
+    except OSError as exc:
+        print(f"ERROR: cannot read body: {exc}", file=sys.stderr)
+        return EXIT_FAILED
+    except events.WriterError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return exc.code
+
+    try:
+        result = events.write_event(
+            home=home,
+            agent=args.agent,
+            project=args.project,
+            event_type=args.event_type,
+            slug=args.slug,
+            body=body,
+            source_ref=args.source_ref,
+            related=events.normalize_related(args.related) if args.related else None,
+            supersedes=args.supersedes,
+            dry_run=args.dry_run,
+        )
+    except events.WriterError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return exc.code
+    except OSError as exc:
+        print(f"ERROR: publication failed: {exc}", file=sys.stderr)
+        return 2
+
+    if args.json_output:
+        print(
+            json.dumps(
+                {
+                    "path": str(result.path),
+                    "status": result.status,
+                    "created_at_utc": result.created_at_utc,
+                    "date": result.created_at_utc[:10],
+                    "agent": args.agent,
+                    "project": args.project,
+                    "type": args.event_type,
+                },
+                indent=2,
+            )
+        )
+    else:
+        print(f"{result.status}: {result.path}")
+        print(f"created_at_utc: {result.created_at_utc}")
+
+    if args.dry_run:
+        print("--- record preview (nothing was written) ---", file=sys.stderr)
+        sys.stderr.flush()
+        sys.stderr.buffer.write(result.record)
+        sys.stderr.buffer.flush()
+    return EXIT_OK
+
+
+def _event_body(args: argparse.Namespace) -> bytes:
+    """The body bytes: ``--body-file`` (a path, or ``-`` for stdin), ``--body``, else piped stdin.
+
+    Trailing newlines are dropped, as the kernel script drops them; the record
+    closes the body with exactly one. A body file is read as text, so its
+    CRLF and CR line endings become LF (:func:`events.body_from_file`); stdin
+    and the inline body are taken as given, both as the script does.
+    """
+    if args.body_file is not None and args.body_file != "-":
+        return events.body_from_file(Path(args.body_file).expanduser().read_bytes())
+    if args.body_file is not None:
+        raw = sys.stdin.buffer.read()
+    elif args.body is not None:
+        raw = args.body.encode("utf-8")
+    elif not sys.stdin.isatty():
+        raw = sys.stdin.buffer.read()
+    else:
+        raise events.WriterError("no body provided: use --body, --body-file <path|->, or pipe the body to stdin", 1)
+    return raw.rstrip(b"\n")
+
+
 def _report(outcome: sync.Outcome) -> int:
     if outcome.lines:
         print("\n".join(outcome.lines), file=sys.stdout if outcome.ok else sys.stderr)

{agent_memory_cli-0.1.0 → agent_memory_cli-0.1.1}/src/agent_memory/doctor.py

@@ -444,15 +444,7 @@ def check_memory_sync(
         state = None
 
     if state is not None:
-        if state.dirty:
-            cat.add(
-                "working-tree",
-                Severity.warn,
-                "working tree — DIRTY memory changes present",
-                "Run `agent-memory push` or resolve changes manually",
-            )
-        else:
-            cat.add("working-tree", Severity.ok, "working tree — clean")
+        _add_working_tree(cat, home, runner, state)
 
         text = f"sync state — {sync_state_text(state)}"
         if not state.has_remote:
@@ -534,6 +526,40 @@ def check_memory_sync(
     return cat
 
 
+def _add_working_tree(cat: Category, home: Path, runner: Optional[GitRunner], state: GitState) -> None:
+    """The tree row, scoped like the counts above it.
+
+    Memory changes inside the allowlist are what ``push`` would publish and
+    read DIRTY. Changes anywhere else are named as outside the allowlist: not
+    memory content, but ``pull`` still refuses a tree that carries them.
+    """
+    if not state.dirty:
+        cat.add("working-tree", Severity.ok, "working tree — clean")
+        return
+    try:
+        changed = sync.changed_paths(home, runner)
+    except sync.SyncError as exc:
+        cat.add("working-tree", Severity.warn, f"working tree — DIRTY; the change readout failed: {exc}")
+        return
+    memory = [path for path in changed if layout.is_allowed_memory_path(path)]
+    elsewhere = [path for path in changed if not layout.is_allowed_memory_path(path)]
+    if memory:
+        text = f"working tree — DIRTY {len(memory)} memory change(s): {_summarize(memory)}"
+        if elsewhere:
+            text += f"; {len(elsewhere)} change(s) outside the memory allowlist"
+        cat.add("working-tree", Severity.warn, text, "Run `agent-memory push` or resolve changes manually")
+    elif elsewhere:
+        cat.add(
+            "working-tree",
+            Severity.warn,
+            f"working tree — {len(elsewhere)} change(s) outside the memory allowlist: {_summarize(elsewhere)}; "
+            "no memory change is pending, but memory pull refuses a dirty tree",
+            "Commit, stash or ignore them outside the memory tiers",
+        )
+    else:
+        cat.add("working-tree", Severity.ok, "working tree — clean")
+
+
 def enclosing_repository(home: Path, runner: Optional[GitRunner] = None) -> Optional[Path]:
     """The worktree root when ``home`` sits inside a repository that is not its own; ``None`` when it is the root."""
     root = sync.worktree_root(home, runner)