gitvow 0.2.2__tar.gz → 0.3.0__tar.gz

{gitvow-0.2.2/src/gitvow.egg-info → gitvow-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.2.2
+Version: 0.3.0
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.2.2 → gitvow-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.2.2"
+version = "0.3.0"
 description = "Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies."
 readme = "README.md"
 license = {text = "Apache-2.0"}

{gitvow-0.2.2 → gitvow-0.3.0}/src/gitvow/cli.py

@@ -14,6 +14,7 @@ from .hooks import HANDLERS, LEGACY_NOTES_REF, notes_ref
 from .install import install_repo, install_user, uninstall_repo, uninstall_user
 from .policy import PolicyError, evaluate, load_policy
 from .redact import RedactionError, load_rules, redact
+from .report import build, render_markdown
 from .state import git
 
 
@@ -94,6 +95,31 @@ def cmd_redact(a: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_report(a: argparse.Namespace) -> int:
+    """Per-commit report for base..head; exit 1 when --require-notes and a trailered commit has no note."""
+    try:
+        r = build(os.getcwd(), a.base, a.head)
+    except ValueError as e:
+        print(f"report error: {e}", file=sys.stderr)
+        return 1
+    print(json.dumps(r, indent=1) if a.json else render_markdown(r), end="" if not a.json else "\n")
+    if a.require_notes and r["missing_notes"]:
+        print(f"missing session notes for: {', '.join(r['missing_notes'])}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def cmd_push_notes(a: argparse.Namespace) -> int:
+    import subprocess
+
+    env = {**os.environ, "GITVOW_PUSHING_NOTES": "1"}  # the pre-push hook must not push the same refs again
+    r = subprocess.run(
+        ["git", "push", a.remote, "refs/notes/gitvow/*:refs/notes/gitvow/*"], env=env, capture_output=True, text=True
+    )
+    print((r.stderr or r.stdout).strip() or "notes pushed", file=sys.stderr if r.returncode else sys.stdout)
+    return 1 if r.returncode else 0
+
+
 def cmd_collect(a: argparse.Namespace) -> int:
     w = collect(os.path.expanduser("~"), a.out)
     print(summarize_text(w))
@@ -141,6 +167,15 @@ def main(argv: list[str] | None = None) -> int:
     s = sub.add_parser("redact", help="apply built-in redaction plus your rules files to text")
     s.add_argument("text", nargs="+")
     s.set_defaults(f=cmd_redact)
+    s = sub.add_parser("report", help="per-commit report for a range: trailers, notes, attribution, said vs did")
+    s.add_argument("--base", required=True)
+    s.add_argument("--head", default="HEAD")
+    s.add_argument("--json", action="store_true")
+    s.add_argument("--require-notes", action="store_true")
+    s.set_defaults(f=cmd_report)
+    s = sub.add_parser("push-notes", help="push refs/notes/gitvow/* to a remote (default origin)")
+    s.add_argument("remote", nargs="?", default="origin")
+    s.set_defaults(f=cmd_push_notes)
     s = sub.add_parser("collect", help="gather ledger, logs, trailers and notes into one directory")
     s.add_argument("--out", default=os.path.expanduser("~/Desktop"))
     s.set_defaults(f=cmd_collect)

{gitvow-0.2.2 → gitvow-0.3.0}/src/gitvow/hooks/__init__.py

@@ -29,15 +29,17 @@ def notes_ref(session_id: str | None) -> str:
 def session_start(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
     cwd = h.get("cwd") or os.getcwd()
     st = load_state(cwd)
+    same_session = st.get("session_id") == h.get("session_id")  # a resumed session keeps its counters
     st.update(
         {
             "session_id": h.get("session_id"),
             "transcript_path": h.get("transcript_path"),
-            "started": time.strftime("%Y-%m-%dT%H:%M:%S"),
-            "steps": st.get("steps", 0),
-            "agent_blobs": st.get("agent_blobs", {}) if st.get("session_id") == h.get("session_id") else {},
+            "started": st.get("started") if same_session and st.get("started") else time.strftime("%Y-%m-%dT%H:%M:%S"),
+            "steps": st.get("steps", 0) if same_session else 0,
+            "agent_blobs": st.get("agent_blobs", {}) if same_session else {},
         }
     )
+    st.pop("pending_commit", None)
     save_state(cwd, st)
     log_event(cwd, "session_start", {"session_id": h.get("session_id")})
     return 0, ""

{gitvow-0.2.2 → gitvow-0.3.0}/src/gitvow/install.py

@@ -24,6 +24,17 @@ SELF="$(cd "$(dirname "$0")" && pwd)"; REPOHOOKS="$(cd "$GD/hooks" 2>/dev/null &
 [ -x "$GD/hooks/prepare-commit-msg" ] && [ "$SELF" != "$REPOHOOKS" ] && exec "$GD/hooks/prepare-commit-msg" "$@"
 exit 0
 """
+PRE_PUSH_HOOK = """#!/bin/sh
+# gitvow: push session notes (refs/notes/gitvow/*) to the same remote whenever a branch is pushed.
+# The inner push re-enters this hook; GITVOW_PUSHING_NOTES stops the recursion.
+REMOTE="$1"
+if [ -z "$GITVOW_PUSHING_NOTES" ] && [ -n "$REMOTE" ] && git for-each-ref --count=1 refs/notes/gitvow/ | grep -q .; then
+  GITVOW_PUSHING_NOTES=1 git push --quiet "$REMOTE" 'refs/notes/gitvow/*:refs/notes/gitvow/*' 2>/dev/null || true
+fi
+GD="$(git rev-parse --git-dir)"; SELF="$(cd "$(dirname "$0")" && pwd)"; REPOHOOKS="$(cd "$GD/hooks" 2>/dev/null && pwd || true)"
+[ -x "$GD/hooks/pre-push" ] && [ "$SELF" != "$REPOHOOKS" ] && exec "$GD/hooks/pre-push" "$@"
+exit 0
+"""
 MARKER = "gitvow hook "
 NOTES_GLOB = "refs/notes/gitvow/*"
 NOTES_KEYS = ("notes.displayRef", "notes.rewriteRef")
@@ -106,11 +117,12 @@ def unmerge_settings(path: str) -> None:
 
 def _write_git_hook(dirpath: str) -> str:
     os.makedirs(dirpath, exist_ok=True)
-    p = os.path.join(dirpath, "prepare-commit-msg")
-    with open(p, "w") as fh:
-        fh.write(GIT_HOOK)
-    os.chmod(p, 0o755)  # noqa: S103  # nosec B103 - git runs hooks as the invoking user; must be executable
-    return p
+    for name, body in (("prepare-commit-msg", GIT_HOOK), ("pre-push", PRE_PUSH_HOOK)):
+        p = os.path.join(dirpath, name)
+        with open(p, "w") as fh:
+            fh.write(body)
+        os.chmod(p, 0o755)  # noqa: S103  # nosec B103 - git runs hooks as the invoking user; must be executable
+    return os.path.join(dirpath, "prepare-commit-msg")
 
 
 def install_user(home: str, cmd_prefix: str | None = None) -> list[str]:

gitvow-0.3.0/src/gitvow/report.py

@@ -0,0 +1,140 @@
+"""Per-commit report for a range: trailers paired with session notes, attribution, and said-vs-did."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Any
+
+from .hooks import LEGACY_NOTES_REF, notes_ref
+from .state import git
+
+TRAILER_RE = re.compile(r"^Gitvow-Session:\s*(\S+)", re.M)
+STEP_RE = re.compile(r"^Gitvow-Step:\s*(\d+)", re.M)
+
+
+def _note_for(cwd: str, sha: str, session_id: str) -> dict[str, Any] | None:
+    for ref in (notes_ref(session_id), LEGACY_NOTES_REF):
+        rc, body, _ = git(["notes", f"--ref={ref}", "show", sha], cwd)
+        if rc == 0 and body.startswith("gitvow-session"):
+            try:
+                return json.loads(body.split("\n", 1)[1])
+            except (json.JSONDecodeError, IndexError):
+                return None
+    return None
+
+
+def _changed_files(cwd: str, sha: str) -> list[str]:
+    _, out, _ = git(["show", "--name-only", "--format=", sha], cwd)
+    return [ln for ln in out.splitlines() if ln.strip()]
+
+
+def said_vs_did(plan: str, files: list[str]) -> dict[str, list[str]]:
+    """Which changed files does the stated plan mention (by path or basename, case-insensitive)?"""
+    low = plan.lower()
+    mentioned, unmentioned = [], []
+    for f in files:
+        base = os.path.basename(f).lower()
+        stem = os.path.splitext(base)[0]
+        if f.lower() in low or base in low or (len(stem) > 3 and stem in low):
+            mentioned.append(f)
+        else:
+            unmentioned.append(f)
+    return {"mentioned": mentioned, "unmentioned": unmentioned}
+
+
+def build(cwd: str, base: str, head: str = "HEAD") -> dict[str, Any]:
+    rc, out, err = git(["log", "--reverse", "--format=%H%x00%s%x00%B%x01", f"{base}..{head}"], cwd)
+    if rc != 0:
+        raise ValueError(err or f"cannot list {base}..{head}")
+    commits: list[dict[str, Any]] = []
+    for rec in out.split("\x01"):
+        rec = rec.strip("\n")
+        if not rec.strip():
+            continue
+        sha, subject, body = rec.split("\x00", 2)
+        m = TRAILER_RE.search(body)
+        entry: dict[str, Any] = {"sha": sha, "short": sha[:7], "subject": subject, "files": _changed_files(cwd, sha)}
+        if not m:
+            entry["kind"] = "human"
+            commits.append(entry)
+            continue
+        sid = m.group(1)
+        sm = STEP_RE.search(body)
+        entry.update({"kind": "agent", "session_id": sid, "step": int(sm.group(1)) if sm else None})
+        note = _note_for(cwd, sha, sid)
+        entry["note_found"] = note is not None
+        if note:
+            plan = note.get("last_stated_plan") or ""
+            att = note.get("attribution") or {}
+            entry.update(
+                {
+                    "plan": plan,
+                    "tools_used": note.get("tools_used", []),
+                    "tool_calls": note.get("tool_calls_so_far"),
+                    "turns": note.get("assistant_turns_so_far"),
+                    "attribution": {
+                        "files_in_commit": att.get("files_in_commit"),
+                        "touched_by_agent": att.get("touched_by_agent"),
+                        "agent_share": att.get("agent_share"),
+                        "lines_changed_by_human_after_agent": att.get("lines_changed_by_human_after_agent"),
+                    },
+                    "said_vs_did": said_vs_did(plan, entry["files"]),
+                }
+            )
+        commits.append(entry)
+    agent = [c for c in commits if c["kind"] == "agent"]
+    return {
+        "base": base,
+        "head": head,
+        "commits": commits,
+        "agent_commits": len(agent),
+        "human_commits": len(commits) - len(agent),
+        "missing_notes": [c["short"] for c in agent if not c["note_found"]],
+    }
+
+
+def render_markdown(r: dict[str, Any]) -> str:
+    lines = [
+        f"## gitvow: {r['agent_commits']} agent commit{'s' if r['agent_commits'] != 1 else ''}, "
+        f"{r['human_commits']} human commit{'s' if r['human_commits'] != 1 else ''}",
+        "",
+    ]
+    if r["missing_notes"]:
+        lines += [
+            f"> **Missing session notes** for {', '.join(r['missing_notes'])}. "
+            "The author's notes were not pushed; run `gitvow push-notes` or `git push origin 'refs/notes/gitvow/*'`.",
+            "",
+        ]
+    for c in r["commits"]:
+        if c["kind"] == "human":
+            lines += [f"### {c['short']} {c['subject']} — no session trailer (made by a person)", ""]
+            continue
+        sid = c["session_id"][:8]
+        lines.append(
+            f"### {c['short']} {c['subject']} — session {sid}, step {c['step'] if c['step'] is not None else '?'}"
+        )
+        if not c["note_found"]:
+            lines += ["**Session note:** missing (not pushed)", ""]
+            continue
+        plan = c["plan"].strip().replace("\n", " ")
+        lines.append(f"**Plan:** {plan[:400] if plan else '(none stated before committing)'}")
+        tools = ", ".join(c["tools_used"]) or "none recorded"
+        lines.append(f"**Tools:** {tools} · {c['tool_calls']} tool calls · {c['turns']} turns")
+        a = c["attribution"]
+        share = "n/a" if a["agent_share"] is None else f"{a['agent_share']:.2f}"
+        lines.append(
+            f"**Attribution:** {a['files_in_commit']} file{'s' if a['files_in_commit'] != 1 else ''}, "
+            f"agent share {share}, {a['lines_changed_by_human_after_agent'] or 0} lines changed by a human after the agent"
+        )
+        svd = c["said_vs_did"]
+        parts = []
+        if svd["mentioned"]:
+            parts.append(", ".join(svd["mentioned"]) + " mentioned in plan ✓")
+        if svd["unmentioned"]:
+            parts.append(", ".join(svd["unmentioned"]) + " **not mentioned in plan**")
+        if not plan:
+            parts.append("no plan to compare")
+        lines += ["**Said vs did:** " + " · ".join(parts), ""]
+    return "\n".join(lines).rstrip() + "\n"

{gitvow-0.2.2 → gitvow-0.3.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.2.2
+Version: 0.3.0
 Summary: Provenance and policy gate for AI-agent coding sessions: session trailers on commits, redacted session notes in git, a tool-call gate, and a local ledger. No runtime dependencies.
 Author-email: Nikhil Bora <nikhil@wirevow.com>
 License: Apache-2.0

{gitvow-0.2.2 → gitvow-0.3.0}/src/gitvow.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ src/gitvow/default_policy.json
 src/gitvow/install.py
 src/gitvow/policy.py
 src/gitvow/redact.py
+src/gitvow/report.py
 src/gitvow/selftest.py
 src/gitvow/state.py
 src/gitvow/transcript.py
@@ -24,4 +25,5 @@ tests/test_hooks.py
 tests/test_install_cli.py
 tests/test_packaging.py
 tests/test_policy.py
-tests/test_redact.py
+tests/test_redact.py
+tests/test_report.py

{gitvow-0.2.2 → gitvow-0.3.0}/tests/test_hooks.py

@@ -216,3 +216,20 @@ def test_invalid_rules_fail_closed_nothing_written(repo, home, payload, transcri
     log = (repo / ".git" / "gitvow-hooks.log").read_text()
     assert '"kind": "redaction_unavailable"' in log
     assert "detail" not in [k for ln in log.splitlines() for k in json.loads(ln) if json.loads(ln)["kind"] == "allowed"]
+
+
+def test_new_session_resets_steps_and_blobs_but_resume_keeps_them(repo, home, payload):
+    session_start(payload("SessionStart"), str(home))
+    pre_tool_use(payload("PreToolUse", "Bash", {"command": "git commit -m x"}), str(home))
+    (repo / "a.txt").write_text("b\n")
+    post_tool_use(payload("PostToolUse", "Edit", {"file_path": "a.txt"}), str(home))
+    st = json.loads((repo / ".git" / "gitvow-session.json").read_text())
+    assert st["steps"] == 1 and st["agent_blobs"] and "pending_commit" in st
+    session_start(payload("SessionStart"), str(home))  # same id: resume
+    st = json.loads((repo / ".git" / "gitvow-session.json").read_text())
+    assert st["steps"] == 1 and st["agent_blobs"] and "pending_commit" not in st
+    p = payload("SessionStart")
+    p["session_id"] = "sess-2"
+    session_start(p, str(home))  # a new session in the same repo starts from zero
+    st = json.loads((repo / ".git" / "gitvow-session.json").read_text())
+    assert st["session_id"] == "sess-2" and st["steps"] == 0 and st["agent_blobs"] == {}

gitvow-0.3.0/tests/test_report.py

@@ -0,0 +1,84 @@
+import json
+import time
+
+from gitvow import cli
+from gitvow.hooks import post_tool_use, pre_tool_use, session_start
+from gitvow.install import _write_git_hook
+from gitvow.report import build, render_markdown, said_vs_did
+from tests.conftest import git
+
+
+def test_said_vs_did_matches_path_basename_or_stem():
+    r = said_vs_did(
+        "Fix the cache key in QueryCacheHelper.java and touch calc", ["a/QueryCacheHelper.java", "calc.py", "x/util.go"]
+    )
+    assert r == {"mentioned": ["a/QueryCacheHelper.java", "calc.py"], "unmentioned": ["x/util.go"]}
+    assert said_vs_did("", ["a.py"]) == {"mentioned": [], "unmentioned": ["a.py"]}
+
+
+def _agent_commit(repo, home, payload, transcript, sid, text):
+    p = payload("SessionStart", transcript=transcript)
+    p["session_id"] = sid
+    session_start(p, str(home))
+    (repo / "a.txt").write_text(text)
+    post_tool_use({**p, "tool_name": "Edit", "tool_input": {"file_path": "a.txt"}}, str(home))
+    pre_tool_use({**p, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, str(home))
+    git(repo, "commit", "-qam", f"agent {sid}")
+    post_tool_use({**p, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, str(home))
+
+
+def test_report_pairs_trailers_with_notes_and_flags_missing(repo, home, payload, transcript, monkeypatch, capsys):
+    _write_git_hook(str(repo / ".gitvow" / "git-hooks"))
+    git(repo, "config", "core.hooksPath", ".gitvow/git-hooks")
+    base = git(repo, "rev-parse", "HEAD")
+    _agent_commit(repo, home, payload, transcript, "s-aaa", "one\n")
+    (repo / "h.txt").write_text("human\n")
+    git(repo, "add", "h.txt")
+    git(repo, "commit", "-qm", "human commit")
+    _agent_commit(repo, home, payload, transcript, "s-bbb", "two\n")
+    git(repo, "update-ref", "-d", "refs/notes/gitvow/s-bbb")  # simulate notes never pushed
+    r = build(str(repo), base, "HEAD")
+    assert r["agent_commits"] == 2 and r["human_commits"] == 1 and len(r["missing_notes"]) == 1
+    kinds = [c["kind"] for c in r["commits"]]
+    assert kinds == ["agent", "human", "agent"]
+    first = r["commits"][0]
+    assert first["note_found"] and first["attribution"]["agent_share"] == 1.0 and first["step"] == 1
+    assert "[github-token]" in first["plan"]  # redacted plan travels into the report
+    assert first["said_vs_did"]["unmentioned"] == ["a.txt"]
+    md = render_markdown(r)
+    assert "2 agent commits, 1 human commit" in md and "Missing session notes" in md
+    assert "made by a person" in md and "not mentioned in plan" in md and "ghp_" not in md
+    monkeypatch.chdir(repo)
+    assert cli.main(["report", "--base", base]) == 0
+    assert cli.main(["report", "--base", base, "--require-notes"]) == 1
+    assert "missing session notes" in capsys.readouterr().err
+    assert cli.main(["report", "--base", base, "--json"]) == 0
+    assert json.loads(capsys.readouterr().out)["agent_commits"] == 2
+    assert cli.main(["report", "--base", "nonexistent-rev"]) == 1
+
+
+def test_pre_push_hook_pushes_notes_with_branch(repo, home, tmp_path):
+    remote = tmp_path / "remote.git"
+    git(remote.parent, "init", "-q", "--bare", str(remote))
+    git(repo, "remote", "add", "origin", str(remote))
+    _write_git_hook(str(repo / ".gitvow" / "git-hooks"))
+    git(repo, "config", "core.hooksPath", ".gitvow/git-hooks")
+    assert (repo / ".gitvow" / "git-hooks" / "pre-push").exists()
+    git(repo, "notes", "--ref=gitvow/s1", "add", "-m", "gitvow-session\n{}", "HEAD")
+    branch = git(repo, "branch", "--show-current")
+    git(repo, "push", "-q", "origin", branch)
+    assert git(remote, "for-each-ref", "--format=%(refname)", "refs/notes/gitvow/") == "refs/notes/gitvow/s1"
+    # push-notes by hand, and idempotent second push
+    (repo / "a.txt").write_text("n\n")
+    git(repo, "commit", "-qam", "n")
+    git(repo, "notes", "--ref=gitvow/s2", "add", "-m", "gitvow-session\n{}", "HEAD")
+    import os
+
+    cwd = os.getcwd()
+    os.chdir(repo)
+    try:
+        assert cli.main(["push-notes"]) == 0
+    finally:
+        os.chdir(cwd)
+    assert "refs/notes/gitvow/s2" in git(remote, "for-each-ref", "--format=%(refname)", "refs/notes/gitvow/")
+    assert time.time() > 0