agent-overwrite-grader 0.1.0__tar.gz

agent_overwrite_grader-0.1.0/.gitignore

@@ -0,0 +1,18 @@
+.*
+!.gitignore
+__pycache__/
+*.pyc
+build/
+dist/
+*.egg-info/
+data/
+out/
+*.log
+entity.yaml
+!.claude-plugin/
+!.claude/
+.claude/*
+!.claude/settings.json
+node_modules/
+test-results/
+playwright-report/

agent_overwrite_grader-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 memento
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_overwrite_grader-0.1.0/PKG-INFO

@@ -0,0 +1,59 @@
+Metadata-Version: 2.5
+Name: agent-overwrite-grader
+Version: 0.1.0
+Summary: Which files did two of your coding agents write within the same hour? Read from your local git log.
+Project-URL: Homepage, https://overflow.games/memento/grader/?ref=pypi
+Project-URL: memento Team, https://overflow.games/memento/?ref=pypi
+Author: memento
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai-agents,claude-code,codex,git,merge-conflicts,parallel-agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# agent-overwrite-grader
+
+**Did two of your coding agents write the same file within the hour?** Run this in your repository:
+
+```
+pipx run agent-overwrite-grader
+```
+
+It reads your local `git log` for the last month and lists every file two sessions (two authors, or two branches) changed less than an hour apart: the edits most likely to overwrite each other. Nothing is sent anywhere; it is standard-library Python 3.9+, with no dependencies.
+
+```
+5 files written by two sessions within an hour, in 2 days of history.
+17 commits by 4 sessions read, on this machine only.
+
+  3  src/routes.ts
+     c11c653 claude-code on agent/auth, Oct 5 09:14, then 8 min later 83f4ab6 codex on agent/billing (3 such pairs)
+  2  src/db/schema.sql
+     c73c1bd codex on agent/billing, Oct 6 09:00, then 12 min later 9a9532b claude-code on agent/auth (2 such pairs)
+  2  package.json
+     271b801 claude-code-2 on agent/search, Oct 5 09:47, then 8 min later 75e6e7b dev on main (2 such pairs)
+```
+
+## Options
+
+```
+agent-overwrite-grader [REPO] [--since "2 weeks ago"] [--top 12] [--json]
+agent-overwrite-grader --log saved.log      # grade a saved log; '-' reads stdin
+```
+
+`--log` takes the output of `git log --all --source --name-only --format='%H|%an|%aI|%S'`.
+
+## The rule
+
+Two commits are two sessions when their authors differ, or both carry a branch name and the names differ. A file collides when two sessions wrote it 60 minutes apart or less. Files rank by how many such pairs they have. The same rule runs in the browser at https://overflow.games/memento/grader/?ref=pypi.
+
+## The fix
+
+memento Team gives each file one owner at a time across machines: a session claims a path before it edits, and the next one waits. Pre-order at https://overflow.games/memento/?ref=pypi (10 USD per agent a month).
+
+MIT licensed.

agent_overwrite_grader-0.1.0/README.md

@@ -0,0 +1,40 @@
+# agent-overwrite-grader
+
+**Did two of your coding agents write the same file within the hour?** Run this in your repository:
+
+```
+pipx run agent-overwrite-grader
+```
+
+It reads your local `git log` for the last month and lists every file two sessions (two authors, or two branches) changed less than an hour apart: the edits most likely to overwrite each other. Nothing is sent anywhere; it is standard-library Python 3.9+, with no dependencies.
+
+```
+5 files written by two sessions within an hour, in 2 days of history.
+17 commits by 4 sessions read, on this machine only.
+
+  3  src/routes.ts
+     c11c653 claude-code on agent/auth, Oct 5 09:14, then 8 min later 83f4ab6 codex on agent/billing (3 such pairs)
+  2  src/db/schema.sql
+     c73c1bd codex on agent/billing, Oct 6 09:00, then 12 min later 9a9532b claude-code on agent/auth (2 such pairs)
+  2  package.json
+     271b801 claude-code-2 on agent/search, Oct 5 09:47, then 8 min later 75e6e7b dev on main (2 such pairs)
+```
+
+## Options
+
+```
+agent-overwrite-grader [REPO] [--since "2 weeks ago"] [--top 12] [--json]
+agent-overwrite-grader --log saved.log      # grade a saved log; '-' reads stdin
+```
+
+`--log` takes the output of `git log --all --source --name-only --format='%H|%an|%aI|%S'`.
+
+## The rule
+
+Two commits are two sessions when their authors differ, or both carry a branch name and the names differ. A file collides when two sessions wrote it 60 minutes apart or less. Files rank by how many such pairs they have. The same rule runs in the browser at https://overflow.games/memento/grader/?ref=pypi.
+
+## The fix
+
+memento Team gives each file one owner at a time across machines: a session claims a path before it edits, and the next one waits. Pre-order at https://overflow.games/memento/?ref=pypi (10 USD per agent a month).
+
+MIT licensed.

agent_overwrite_grader-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agent-overwrite-grader"
+version = "0.1.0"
+description = "Which files did two of your coding agents write within the same hour? Read from your local git log."
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+requires-python = ">=3.9"
+dependencies = []
+authors = [{ name = "memento" }]
+keywords = ["git", "ai-agents", "claude-code", "codex", "merge-conflicts", "parallel-agents"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Topic :: Software Development :: Version Control :: Git",
+]
+
+[project.urls]
+Homepage = "https://overflow.games/memento/grader/?ref=pypi"
+"memento Team" = "https://overflow.games/memento/?ref=pypi"
+
+[project.scripts]
+agent-overwrite-grader = "agent_overwrite_grader.cli:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/agent_overwrite_grader"]

agent_overwrite_grader-0.1.0/src/agent_overwrite_grader/__init__.py

@@ -0,0 +1,5 @@
+"""agent-overwrite-grader: which files two coding agent sessions wrote within the same hour, read from git log."""
+from .grade import COMMAND, WINDOW_MIN, grade, parse, score_line
+
+__version__ = "0.1.0"
+__all__ = ["COMMAND", "WINDOW_MIN", "grade", "parse", "score_line", "__version__"]

agent_overwrite_grader-0.1.0/src/agent_overwrite_grader/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

agent_overwrite_grader-0.1.0/src/agent_overwrite_grader/cli.py

@@ -0,0 +1,90 @@
+"""The command: run git log here, grade it, print the files most likely overwritten. Nothing leaves this machine."""
+import argparse
+import json
+import subprocess
+import sys
+from datetime import datetime
+
+from . import __version__
+from .grade import grade, score_line
+
+PREORDER = "https://overflow.games/memento/?ref=pypi"
+FIX = ("memento Team gives each file one owner at a time across machines: "
+       "a session claims a path before it edits, and the next one waits.")
+
+
+def git_log(repo, since):
+    cmd = ["git", "-C", repo, "log", "--all", "--source", "--name-only",
+           "--since=" + since, "--format=%H|%an|%aI|%S"]
+    try:
+        r = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    except OSError as e:
+        raise SystemExit("agent-overwrite-grader: git is not on the PATH (%s)" % e)
+    if r.returncode:
+        raise SystemExit("agent-overwrite-grader: git log failed in %s: %s"
+                         % (repo, r.stderr.decode("utf-8", "replace").strip()))
+    return r.stdout.decode("utf-8", "replace")
+
+
+def when(ms):
+    t = datetime.fromtimestamp(ms / 1000)
+    return "%s %d %s" % (t.strftime("%b"), t.day, t.strftime("%H:%M"))
+
+
+def who(c):
+    return c["hash"][:7] + " " + c["author"] + (" on " + c["ref"] if c["ref"] else "")
+
+
+def text(report, top):
+    out = [score_line(report), "%d commits by %d sessions read, on this machine only." % (report["commits"], report["sessions"]), ""]
+    for f in report["files"][:top]:
+        p = f["pairs"][0]
+        line = "  %d  %s" % (f["count"], f["file"])
+        pair = "     %s, %s, then %d min later %s" % (who(p["a"]), when(p["a"]["when"]), p["minutes"], who(p["b"]))
+        if f["count"] > 1:
+            pair += " (%d such pairs)" % f["count"]
+        out += [line, pair]
+    n = len(report["files"])
+    if n > top:
+        out.append("And %d more %s." % (n - top, "file" if n - top == 1 else "files"))
+    elif n == 0:
+        out.append("Nothing collided in this history. The more agents run at once, the sooner it does.")
+    out += ["", FIX, "Pre-order memento Team, 10 USD per agent a month: " + PREORDER]
+    return "\n".join(out)
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="agent-overwrite-grader",
+        description="List every file two sessions (two authors, or two branches) changed less than an hour apart: "
+                    "the edits most likely to overwrite each other. It reads the local git log; nothing is sent anywhere.")
+    ap.add_argument("repo", nargs="?", default=".", help="the repository to read (default: here)")
+    ap.add_argument("--since", default="1 month ago", help="how far back to read (default: 1 month ago)")
+    ap.add_argument("--log", metavar="FILE", help="grade a saved log instead ('-' for stdin), in the format of: "
+                    "git log --all --source --name-only --format='%%H|%%an|%%aI|%%S'")
+    ap.add_argument("--top", type=int, default=12, help="files to show (default: 12)")
+    ap.add_argument("--json", action="store_true", help="print the report as JSON")
+    ap.add_argument("--version", action="version", version="%(prog)s " + __version__)
+    a = ap.parse_args(argv)
+    try:
+        if a.log == "-":
+            log = sys.stdin.read()
+        elif a.log:
+            with open(a.log, encoding="utf-8", errors="replace") as f:
+                log = f.read()
+        else:
+            log = git_log(a.repo, a.since)
+    except SystemExit as e:
+        print(e, file=sys.stderr)
+        return 2
+    report = grade(log)
+    if not report["commits"] and a.log:
+        print("agent-overwrite-grader: no commit in that text; save the output of the git log command in --help.",
+              file=sys.stderr)
+        return 1
+    if a.json:
+        report["preorder"] = PREORDER
+        print(json.dumps(report, indent=2))
+    else:
+        print(text(report, a.top))
+    return 0

agent_overwrite_grader-0.1.0/src/agent_overwrite_grader/grade.py

@@ -0,0 +1,85 @@
+"""The grading rule: which files two sessions wrote within an hour, read from a git log.
+
+A line-for-line port of the web grader's grade.js; a shared fixture test keeps the two verdicts equal.
+"""
+import math
+import re
+from datetime import datetime
+
+COMMAND = "git log --all --source --name-only --since='1 month ago' --format='%H|%an|%aI|%S'"
+WINDOW_MIN = 60
+HEAD = re.compile(r"^[0-9a-f]{7,64}\|")
+
+
+def branch(ref):
+    """A ref as git prints it (%S, or %D's decorations) to a branch name; "" when the commit carries none."""
+    names = [s.strip() for s in (ref or "").split(",")]
+    names = [re.sub(r"^HEAD -> ", "", s) for s in names]
+    names = [s for s in names if s and s != "HEAD" and not s.startswith("tag: ") and not s.startswith("refs/tags/")]
+    if not names:
+        return ""
+    return re.sub(r"^refs/remotes/[^/]+/", "", re.sub(r"^refs/heads/", "", names[0]))
+
+
+def millis(text):
+    """An ISO 8601 date with its offset to epoch milliseconds; None when it does not read as one."""
+    try:
+        when = datetime.fromisoformat(text.strip().replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    return int(round(when.timestamp() * 1000))
+
+
+def parse(text):
+    commits, cur = [], None
+    for line in re.split(r"\r?\n", str(text or "")):
+        if HEAD.match(line):
+            p = line.split("|")
+            when = millis(p[-2]) if len(p) >= 4 else None
+            if when is not None:
+                cur = {"hash": p[0], "author": "|".join(p[1:-2]), "when": when, "ref": branch(p[-1]), "files": []}
+                commits.append(cur)
+                continue
+        f = line.strip()
+        if cur is not None and f:
+            cur["files"].append(f)
+    return commits
+
+
+def two_sessions(a, b):
+    """Two commits are two sessions when their authors differ, or both carry a branch and the branches differ."""
+    return a["author"] != b["author"] or bool(a["ref"] and b["ref"] and a["ref"] != b["ref"])
+
+
+def grade(text):
+    commits, by_file = parse(text), {}
+    for c in commits:
+        for f in c["files"]:
+            by_file.setdefault(f, []).append(c)
+    files = []
+    for name, writes in by_file.items():
+        writes = sorted(writes, key=lambda c: c["when"])
+        pairs, latest = [], 0
+        for i in range(1, len(writes)):
+            j = i - 1
+            while j >= 0 and writes[i]["when"] - writes[j]["when"] <= WINDOW_MIN * 60000:
+                if two_sessions(writes[i], writes[j]):
+                    minutes = int(math.floor((writes[i]["when"] - writes[j]["when"]) / 60000 + 0.5))
+                    pairs.append({"a": writes[j], "b": writes[i], "minutes": minutes})
+                    latest = max(latest, writes[i]["when"])
+                j -= 1
+        if pairs:
+            pairs.sort(key=lambda p: p["minutes"])
+            files.append({"file": name, "count": len(pairs), "latest": latest, "pairs": pairs[:3]})
+    files.sort(key=lambda f: (-f["count"], -f["latest"], f["file"]))
+    times = [c["when"] for c in commits]
+    days = max(1, math.ceil((max(times) - min(times)) / 864e5)) if times else 0
+    sessions = {(c["author"], c["ref"]) for c in commits}
+    return {"commits": len(commits), "sessions": len(sessions), "days": days, "files": files}
+
+
+def score_line(report):
+    n = len(report["files"])
+    head = "No file" if n == 0 else "1 file" if n == 1 else "%d files" % n
+    return "%s written by two sessions within an hour, in %d %s of history." % (
+        head, report["days"], "day" if report["days"] == 1 else "days")