gitvow 0.5.0__tar.gz → 0.6.0__tar.gz

{gitvow-0.5.0/src/gitvow.egg-info → gitvow-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.5.0
+Version: 0.6.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.5.0 → gitvow-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.5.0"
+version = "0.6.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.6.0/src/gitvow/adapters.py

@@ -0,0 +1,155 @@
+"""Adapters: translate other agents' hook payloads into the Claude Code shape gitvow's handlers understand,
+and render decisions in each agent's native form. See docs/reference/adapters.md."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+AGENTS = ("claude", "codex", "gemini", "cursor")
+
+# agent event -> gitvow handler
+EVENT_MAP: dict[str, dict[str, str]] = {
+    "claude": {
+        "SessionStart": "SessionStart",
+        "PreToolUse": "PreToolUse",
+        "PostToolUse": "PostToolUse",
+        "Stop": "Stop",
+    },
+    "codex": {"SessionStart": "SessionStart", "PreToolUse": "PreToolUse", "PostToolUse": "PostToolUse", "Stop": "Stop"},
+    "gemini": {
+        "SessionStart": "SessionStart",
+        "BeforeTool": "PreToolUse",
+        "AfterTool": "PostToolUse",
+        "SessionEnd": "Stop",
+    },
+    "cursor": {
+        "sessionStart": "SessionStart",
+        "preToolUse": "PreToolUse",
+        "beforeShellExecution": "PreToolUse",
+        "beforeMCPExecution": "PreToolUse",
+        "afterFileEdit": "PostToolUse",
+        "afterShellExecution": "PostToolUse",
+        "stop": "Stop",
+    },
+}
+
+GEMINI_TOOLS = {"run_shell_command": "Bash", "write_file": "Write", "replace": "Edit", "edit": "Edit"}
+PATCH_FILE_RE = re.compile(r"^\*\*\* (Update|Add|Delete) File: (.+)$")
+
+
+def parse_apply_patch(text: str) -> list[dict[str, str]]:
+    """Codex apply_patch text -> [{file_path, old_string, new_string, op}] per touched file."""
+    files: list[dict[str, str]] = []
+    cur: dict[str, Any] | None = None
+    for line in (text or "").splitlines():
+        m = PATCH_FILE_RE.match(line.strip())
+        if m:
+            cur = {"op": m.group(1).lower(), "file_path": m.group(2).strip(), "old": [], "new": []}
+            files.append(cur)
+            continue
+        if cur is None or line.startswith("*** "):
+            continue
+        if line.startswith("+"):
+            cur["new"].append(line[1:])
+        elif line.startswith("-"):
+            cur["old"].append(line[1:])
+    return [
+        {
+            "file_path": f["file_path"],
+            "op": f["op"],
+            "old_string": "\n".join(f["old"]),
+            "new_string": "\n".join(f["new"]),
+        }
+        for f in files
+    ]
+
+
+def normalize(agent: str, event: str, payload: dict[str, Any]) -> list[tuple[str, dict[str, Any]]]:
+    """Return one or more (gitvow_event, claude_shaped_payload). Codex patches expand to one Edit per file."""
+    if agent not in AGENTS:
+        raise ValueError(f"unknown agent {agent}")
+    gv_event = EVENT_MAP[agent].get(event)
+    if not gv_event:
+        return []
+    base = {
+        "session_id": payload.get("session_id") or payload.get("conversation_id") or "",
+        "transcript_path": payload.get("transcript_path") or "",
+        "cwd": payload.get("cwd") or (payload.get("workspace_roots") or [None])[0] or "",
+        "hook_event_name": gv_event,
+        "agent": agent,
+    }
+    if gv_event in ("SessionStart", "Stop"):
+        return [(gv_event, base)]
+    tool = str(payload.get("tool_name") or "")
+    inp = dict(payload.get("tool_input") or {})
+    if agent == "codex":
+        if tool == "apply_patch":
+            out = []
+            for f in parse_apply_patch(str(inp.get("command") or inp.get("patch") or "")):
+                out.append(
+                    (
+                        gv_event,
+                        {
+                            **base,
+                            "tool_name": "Edit",
+                            "tool_input": {
+                                "file_path": f["file_path"],
+                                "old_string": f["old_string"],
+                                "new_string": f["new_string"],
+                                "apply_patch_op": f["op"],
+                            },
+                        },
+                    )
+                )
+            return out or [(gv_event, {**base, "tool_name": "Edit", "tool_input": {}})]
+        return [(gv_event, {**base, "tool_name": tool, "tool_input": inp})]
+    if agent == "gemini":
+        return [(gv_event, {**base, "tool_name": GEMINI_TOOLS.get(tool, tool), "tool_input": inp})]
+    if agent == "cursor":
+        if event == "beforeShellExecution" or event == "afterShellExecution":
+            return [(gv_event, {**base, "tool_name": "Bash", "tool_input": {"command": payload.get("command", "")}})]
+        if event == "afterFileEdit":
+            edits = payload.get("edits") or []
+            return [
+                (
+                    gv_event,
+                    {
+                        **base,
+                        "tool_name": "Edit",
+                        "tool_input": {
+                            "file_path": payload.get("file_path", ""),
+                            "old_string": "\n".join(str(e.get("old_string", "")) for e in edits),
+                            "new_string": "\n".join(str(e.get("new_string", "")) for e in edits),
+                        },
+                    },
+                )
+            ]
+        if event == "beforeMCPExecution":
+            name = tool if tool.startswith("mcp__") else f"mcp__{payload.get('mcp_server_name', 'server')}__{tool}"
+            return [(gv_event, {**base, "tool_name": name, "tool_input": inp})]
+        # generic preToolUse: Cursor's own tool names
+        mapped = {
+            "Shell": "Bash",
+            "shell": "Bash",
+            "run_terminal_cmd": "Bash",
+            "edit_file": "Edit",
+            "write_file": "Write",
+            "Edit": "Edit",
+            "Write": "Write",
+        }.get(tool, tool)
+        if mapped == "Bash" and "command" not in inp and payload.get("command"):
+            inp["command"] = payload["command"]
+        return [(gv_event, {**base, "tool_name": mapped, "tool_input": inp})]
+    return [(gv_event, {**base, "tool_name": tool, "tool_input": inp})]
+
+
+def respond(agent: str, code: int, msg: str) -> tuple[int, str, str]:
+    """(exit code, stdout, stderr) in the agent's form. gitvow's code 2 means blocked; the message says DENY or CONFIRM."""
+    if agent == "cursor":
+        if code == 2:
+            perm = "deny" if msg.startswith("BLOCKED") else "ask"
+            return 0, json.dumps({"permission": perm, "user_message": msg, "agent_message": msg}), ""
+        return 0, json.dumps({"permission": "allow"}), msg
+    return code, "", msg

{gitvow-0.5.0 → gitvow-0.6.0}/src/gitvow/cli.py

@@ -21,31 +21,56 @@ from .state import git
 
 
 def cmd_hook(a: argparse.Namespace) -> int:
+    from .adapters import normalize, respond
+
     try:
         payload = json.load(sys.stdin)
     except json.JSONDecodeError:
         payload = {}
-    handler = HANDLERS.get(a.event)
-    if not handler:
-        print(f"unknown hook event {a.event}", file=sys.stderr)
+    agent = a.agent or "claude"
+    try:
+        calls = normalize(agent, a.event, payload)
+    except ValueError as e:
+        print(str(e), file=sys.stderr)
         return 1
-    code, msg = handler(payload)
-    if msg:
-        print(msg, file=sys.stderr)
-    return code
+    if not calls:
+        return 0  # an event this adapter does not use
+    worst, messages = 0, []
+    for gv_event, p in calls:
+        handler = HANDLERS.get(gv_event)
+        if not handler:
+            print(f"unknown hook event {gv_event}", file=sys.stderr)
+            return 1
+        code, msg = handler(p)
+        if code == 2 and len(calls) > 1 and p.get("tool_input", {}).get("file_path"):
+            msg = f"{msg} [file: {p['tool_input']['file_path']}]"
+        worst = max(worst, code)
+        if msg:
+            messages.append(msg)
+    exit_code, out, err = respond(agent, worst, "\n".join(messages))
+    if out:
+        print(out)
+    if err:
+        print(err, file=sys.stderr)
+    return exit_code
 
 
 def cmd_install(a: argparse.Namespace) -> int:
-    done = install_user(os.path.expanduser("~")) if a.user else install_repo(os.path.abspath(a.repo))
+    agent = a.agent or "claude"
+    if a.user:
+        done = install_user(os.path.expanduser("~"), agent=agent)
+    else:
+        done = install_repo(os.path.abspath(a.repo), agent=agent)
     print("\n".join(done))
     return 0
 
 
 def cmd_uninstall(a: argparse.Namespace) -> int:
+    agent = a.agent or "claude"
     done = (
-        uninstall_user(os.path.expanduser("~"), a.purge_policy, a.purge_ledger)
+        uninstall_user(os.path.expanduser("~"), a.purge_policy, a.purge_ledger, agent=agent)
         if a.user
-        else uninstall_repo(os.path.abspath(a.repo), a.purge_notes, a.purge_snapshots)
+        else uninstall_repo(os.path.abspath(a.repo), a.purge_notes, a.purge_snapshots, agent=agent)
     )
     print("\n".join(done))
     return 0
@@ -210,8 +235,10 @@ def cmd_summarize(a: argparse.Namespace) -> int:
 
 
 def cmd_selftest(a: argparse.Namespace) -> int:
-    from .selftest import run
+    from .selftest import run, run_agent
 
+    if a.agent and a.agent != "claude":
+        return run_agent(a.agent)
     return run()
 
 
@@ -219,12 +246,14 @@ def main(argv: list[str] | None = None) -> int:
     p = argparse.ArgumentParser(prog="gitvow", description="Provenance and policy gate for agent coding sessions.")
     p.add_argument("--version", action="version", version=f"gitvow {__version__}")
     sub = p.add_subparsers(dest="cmd", required=True)
-    s = sub.add_parser("hook", help="run as a Claude Code hook (reads JSON on stdin)")
+    s = sub.add_parser("hook", help="run as an agent hook (reads the agent's JSON on stdin)")
+    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor"], default="claude")
     s.add_argument("event")
     s.set_defaults(f=cmd_hook)
     s = sub.add_parser("install", help="install per user (--user) or into a repo")
     s.add_argument("repo", nargs="?", default=".")
     s.add_argument("--user", action="store_true")
+    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor"], default="claude")
     s.set_defaults(f=cmd_install)
     s = sub.add_parser("uninstall", help="remove what install added")
     s.add_argument("repo", nargs="?", default=".")
@@ -233,6 +262,7 @@ def main(argv: list[str] | None = None) -> int:
     s.add_argument("--purge-policy", action="store_true")
     s.add_argument("--purge-ledger", action="store_true")
     s.add_argument("--purge-snapshots", action="store_true")
+    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor"], default="claude")
     s.set_defaults(f=cmd_uninstall)
     s = sub.add_parser("check", help="dry-run the policy: gitvow check -- git push --force")
     s.add_argument("command", nargs="*")
@@ -284,6 +314,7 @@ def main(argv: list[str] | None = None) -> int:
     s.add_argument("dir")
     s.set_defaults(f=cmd_summarize)
     s = sub.add_parser("selftest", help="prove the hooks work here without touching a real repo")
+    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor"], default="claude")
     s.set_defaults(f=cmd_selftest)
     a = p.parse_args(argv)
     return a.f(a)

{gitvow-0.5.0 → gitvow-0.6.0}/src/gitvow/install.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import shutil
 import sys
 from typing import Any
@@ -82,6 +83,120 @@ def _hook_entries(cmd_prefix: str) -> dict[str, list[dict[str, Any]]]:
     }
 
 
+AGENT_FILES = {
+    "claude": (".claude/settings.json", ".claude/settings.json"),
+    "codex": (".codex/hooks.json", ".codex/hooks.json"),
+    "gemini": (".gemini/settings.json", ".gemini/settings.json"),
+    "cursor": (".cursor/hooks.json", ".cursor/hooks.json"),
+}
+
+
+def _agent_entries(agent: str, cmd_prefix: str) -> dict[str, list[dict[str, Any]]]:
+    """Hook entries in each agent's own schema. Every command carries MARKER so install stays idempotent."""
+    c = f"{cmd_prefix} hook --agent {agent}"
+    if agent == "claude":
+        return _hook_entries(cmd_prefix)
+    if agent == "codex":
+
+        def e(ev: str, matcher: str | None) -> dict[str, Any]:
+            x: dict[str, Any] = {"hooks": [{"type": "command", "command": f"{c} {ev}", "timeout": 30}]}
+            if matcher:
+                x["matcher"] = matcher
+            return x
+
+        return {
+            "SessionStart": [e("SessionStart", None)],
+            "PreToolUse": [e("PreToolUse", "Bash|apply_patch|mcp__.*")],
+            "PostToolUse": [e("PostToolUse", "Bash|apply_patch")],
+            "Stop": [e("Stop", None)],
+        }
+    if agent == "gemini":
+
+        def g(ev: str, matcher: str) -> dict[str, Any]:
+            return {
+                "matcher": matcher,
+                "hooks": [{"name": f"gitvow-{ev}", "type": "command", "command": f"{c} {ev}", "timeout": 30000}],
+            }
+
+        return {
+            "SessionStart": [g("SessionStart", "*")],
+            "BeforeTool": [g("BeforeTool", "run_shell_command|write_file|replace|edit|mcp__.*")],
+            "AfterTool": [g("AfterTool", "run_shell_command|write_file|replace|edit")],
+            "SessionEnd": [g("SessionEnd", "*")],
+        }
+    if agent == "cursor":
+
+        def u(ev: str) -> dict[str, Any]:
+            return {"command": f"{c} {ev}", "type": "command", "timeout": 30, "failClosed": True}
+
+        return {
+            ev: [u(ev)]
+            for ev in (
+                "sessionStart",
+                "preToolUse",
+                "beforeShellExecution",
+                "beforeMCPExecution",
+                "afterFileEdit",
+                "afterShellExecution",
+                "stop",
+            )
+        }
+    raise ValueError(f"unknown agent {agent}")
+
+
+def _is_ours(entry: dict[str, Any]) -> bool:
+    if MARKER in (entry.get("command") or ""):
+        return True
+    return any(MARKER in (h.get("command") or "") for h in entry.get("hooks", []))
+
+
+def merge_agent_settings(path: str, agent: str, cmd_prefix: str) -> None:
+    cur: dict[str, Any] = {}
+    if os.path.exists(path):
+        with open(path) as fh:
+            cur = json.load(fh)
+    if agent == "cursor":
+        cur.setdefault("version", 1)
+    hooks = cur.setdefault("hooks", {})
+    for ev, entries in _agent_entries(agent, cmd_prefix).items():
+        kept = [x for x in hooks.get(ev, []) if not _is_ours(x)]
+        hooks[ev] = kept + entries
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    with open(path, "w") as fh:
+        json.dump(cur, fh, indent=2)
+
+
+def unmerge_agent_settings(path: str) -> None:
+    if not os.path.exists(path):
+        return
+    with open(path) as fh:
+        cur = json.load(fh)
+    hooks = cur.get("hooks", {})
+    for ev in list(hooks):
+        hooks[ev] = [x for x in hooks[ev] if not _is_ours(x)]
+        if not hooks[ev]:
+            del hooks[ev]
+    if not hooks:
+        cur.pop("hooks", None)
+    if cur and cur != {"version": 1}:
+        with open(path, "w") as fh:
+            json.dump(cur, fh, indent=2)
+    else:
+        os.remove(path)
+
+
+def codex_hooks_enabled_hint(home: str) -> str | None:
+    """Codex hooks are opt-in on some versions; point at the config line if it is absent."""
+    cfg = os.path.join(home, ".codex", "config.toml")
+    txt = ""
+    if os.path.exists(cfg):
+        with open(cfg) as fh:
+            txt = fh.read()
+    if re.search(r"^\s*hooks\s*=\s*true", txt, re.M) or re.search(r"^\s*codex_hooks\s*=\s*true", txt, re.M):
+        return None
+    return f"Codex hooks may need enabling: add `hooks = true` under [features] in {cfg}"
+
+
 def merge_settings(path: str, cmd_prefix: str) -> None:
     cur: dict[str, Any] = {}
     if os.path.exists(path):
@@ -125,7 +240,7 @@ def _write_git_hook(dirpath: str) -> str:
     return os.path.join(dirpath, "prepare-commit-msg")
 
 
-def install_user(home: str, cmd_prefix: str | None = None) -> list[str]:
+def install_user(home: str, cmd_prefix: str | None = None, agent: str = "claude") -> list[str]:
     base = os.path.join(home, ".gitvow")
     os.makedirs(base, exist_ok=True)
     cmd_prefix = cmd_prefix or executable_command()
@@ -137,21 +252,34 @@ def install_user(home: str, cmd_prefix: str | None = None) -> list[str]:
         shutil.copy(DEFAULT_POLICY_PATH, pol)
         done.append(f"default policy → {pol}")
     _write_git_hook(os.path.join(base, "git-hooks"))
-    merge_settings(os.path.join(home, ".claude", "settings.json"), cmd_prefix)
+    settings_rel = AGENT_FILES[agent][0]
+    if agent == "claude":
+        merge_settings(os.path.join(home, ".claude", "settings.json"), cmd_prefix)
+    else:
+        merge_agent_settings(os.path.join(home, settings_rel), agent, cmd_prefix)
+        if agent == "codex":
+            hint = codex_hooks_enabled_hint(home)
+            if hint:
+                done.append(hint)
     git(["config", "--global", "core.hooksPath", os.path.join(base, "git-hooks")], home)
     _set_notes_config(home, ["--global"])
     done += [
-        "hooks merged into ~/.claude/settings.json",
+        f"hooks merged into ~/{settings_rel}",
         "global core.hooksPath → ~/.gitvow/git-hooks",
         f"global notes.displayRef / notes.rewriteRef → {NOTES_GLOB}",
     ]
     return done
 
 
-def uninstall_user(home: str, purge_policy: bool = False, purge_ledger: bool = False) -> list[str]:
+def uninstall_user(
+    home: str, purge_policy: bool = False, purge_ledger: bool = False, agent: str = "claude"
+) -> list[str]:
     base = os.path.join(home, ".gitvow")
     done = []
-    unmerge_settings(os.path.join(home, ".claude", "settings.json"))
+    if agent == "claude":
+        unmerge_settings(os.path.join(home, ".claude", "settings.json"))
+    else:
+        unmerge_agent_settings(os.path.join(home, AGENT_FILES[agent][0]))
     rc, cur, _ = git(["config", "--global", "--get", "core.hooksPath"], home)
     if rc == 0 and cur == os.path.join(base, "git-hooks"):
         git(["config", "--global", "--unset", "core.hooksPath"], home)
@@ -164,11 +292,11 @@ def uninstall_user(home: str, purge_policy: bool = False, purge_ledger: bool = F
     if purge_ledger:
         shutil.rmtree(os.path.join(base, "ledger"), ignore_errors=True)
         done.append("ledger removed")
-    done.append("hook entries removed from ~/.claude/settings.json")
+    done.append(f"hook entries removed from ~/{AGENT_FILES[agent][0]}")
     return done
 
 
-def install_repo(repo: str, cmd_prefix: str = "gitvow") -> list[str]:
+def install_repo(repo: str, cmd_prefix: str = "gitvow", agent: str = "claude") -> list[str]:
     base = os.path.join(repo, ".gitvow")
     os.makedirs(base, exist_ok=True)
     from .policy import DEFAULT_POLICY_PATH
@@ -177,21 +305,29 @@ def install_repo(repo: str, cmd_prefix: str = "gitvow") -> list[str]:
     if not os.path.exists(pol):
         shutil.copy(DEFAULT_POLICY_PATH, pol)
     _write_git_hook(os.path.join(base, "git-hooks"))
-    merge_settings(os.path.join(repo, ".claude", "settings.json"), cmd_prefix)
+    if agent == "claude":
+        merge_settings(os.path.join(repo, ".claude", "settings.json"), cmd_prefix)
+    else:
+        merge_agent_settings(os.path.join(repo, AGENT_FILES[agent][1]), agent, cmd_prefix)
     git(["config", "core.hooksPath", ".gitvow/git-hooks"], repo)
     _set_notes_config(repo, [])
     return [
         f"policy → {pol}",
-        "hooks merged into .claude/settings.json",
+        f"hooks merged into {AGENT_FILES[agent][1]}",
         "core.hooksPath → .gitvow/git-hooks",
         f"notes.displayRef / notes.rewriteRef → {NOTES_GLOB}",
         "commit .gitvow/ and .claude/settings.json to share; teammates run: git config core.hooksPath .gitvow/git-hooks",
     ]
 
 
-def uninstall_repo(repo: str, purge_notes: bool = False, purge_snapshots: bool = False) -> list[str]:
+def uninstall_repo(
+    repo: str, purge_notes: bool = False, purge_snapshots: bool = False, agent: str = "claude"
+) -> list[str]:
     done = []
-    unmerge_settings(os.path.join(repo, ".claude", "settings.json"))
+    if agent == "claude":
+        unmerge_settings(os.path.join(repo, ".claude", "settings.json"))
+    else:
+        unmerge_agent_settings(os.path.join(repo, AGENT_FILES[agent][1]))
     rc, cur, _ = git(["config", "--get", "core.hooksPath"], repo)
     if rc == 0 and cur == ".gitvow/git-hooks":
         git(["config", "--unset", "core.hooksPath"], repo)

{gitvow-0.5.0 → gitvow-0.6.0}/src/gitvow/selftest.py

@@ -8,11 +8,118 @@ import shutil
 import subprocess
 import sys
 import tempfile
+from typing import Any
 
 from .hooks import post_tool_use, pre_tool_use, session_start, stop
 from .install import _write_git_hook
 
 
+def run_agent(agent: str) -> int:
+    """Drive the adapter for another agent with that agent's payload shapes: a block and a snapshot."""
+    import json as _json
+
+    from .adapters import normalize, respond
+    from .hooks import HANDLERS
+
+    home = tempfile.mkdtemp(prefix="gitvow-home-")
+    repo = tempfile.mkdtemp(prefix="gitvow-repo-")
+    results: list[tuple[bool, str]] = []
+    try:
+        subprocess.run(["git", "init", "-q"], cwd=repo, check=False)
+        with open(os.path.join(repo, "a.txt"), "w") as fh:
+            fh.write("a\n")
+        samples: dict[str, list[tuple[str, dict[str, Any]]]] = {
+            "codex": [
+                ("SessionStart", {"session_id": "st", "cwd": repo}),
+                (
+                    "PreToolUse",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "Bash",
+                        "tool_input": {"command": "git push --force"},
+                    },
+                ),
+                (
+                    "PostToolUse",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "apply_patch",
+                        "tool_input": {"command": "*** Begin Patch\n*** Update File: a.txt\n+b\n*** End Patch\n"},
+                    },
+                ),
+            ],
+            "gemini": [
+                ("SessionStart", {"session_id": "st", "cwd": repo}),
+                (
+                    "BeforeTool",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "run_shell_command",
+                        "tool_input": {"command": "git push --force"},
+                    },
+                ),
+                (
+                    "AfterTool",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "write_file",
+                        "tool_input": {"file_path": os.path.join(repo, "a.txt"), "content": "b"},
+                    },
+                ),
+            ],
+            "cursor": [
+                ("sessionStart", {"conversation_id": "st", "workspace_roots": [repo]}),
+                (
+                    "beforeShellExecution",
+                    {"conversation_id": "st", "workspace_roots": [repo], "command": "git push --force"},
+                ),
+                (
+                    "afterFileEdit",
+                    {
+                        "conversation_id": "st",
+                        "workspace_roots": [repo],
+                        "file_path": os.path.join(repo, "a.txt"),
+                        "edits": [{"old_string": "a", "new_string": "b"}],
+                    },
+                ),
+            ],
+        }
+        for ev, payload in samples[agent]:
+            worst, msgs = 0, []
+            for gv_event, p in normalize(agent, ev, payload):
+                code, msg = HANDLERS[gv_event](p, home)
+                worst = max(worst, code)
+                if msg:
+                    msgs.append(msg)
+            exit_code, out, _err = respond(agent, worst, "\n".join(msgs))
+            if ev in ("PreToolUse", "BeforeTool", "beforeShellExecution"):
+                blocked = (agent == "cursor" and _json.loads(out).get("permission") == "deny") or (
+                    agent != "cursor" and exit_code == 2
+                )
+                results.append((blocked, f"{agent}: force push denied in the agent's own form"))
+        refs = subprocess.run(
+            ["git", "for-each-ref", "refs/gitvow/snapshots/"], cwd=repo, capture_output=True, text=True
+        ).stdout
+        results.append((refs.strip() != "", f"{agent}: snapshot taken after the agent's edit"))
+        results.append(
+            (os.path.exists(os.path.join(repo, ".git", "gitvow-session.json")), f"{agent}: session recorded")
+        )
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+        shutil.rmtree(repo, ignore_errors=True)
+    for ok, name in results:
+        print(("  ok   " if ok else "  FAIL ") + name)
+    failed = sum(1 for ok, _ in results if not ok)
+    print(
+        f"\nselftest --agent {agent}: {len(results) - failed} passed, {failed} failed (payload shapes from vendor docs; not a real session)"
+    )
+    return 1 if failed else 0
+
+
 def run() -> int:
     home = tempfile.mkdtemp(prefix="gitvow-home-")
     repo = tempfile.mkdtemp(prefix="gitvow-repo-")

{gitvow-0.5.0 → gitvow-0.6.0}/src/gitvow/snapshots.py

@@ -11,7 +11,7 @@ import tempfile
 import time
 from typing import Any
 
-from .state import git, git_dir, load_state, save_state, toplevel
+from .state import git, git_dir, load_state, log_event, save_state, toplevel
 
 REF_PREFIX = "refs/gitvow/snapshots"
 DEFAULTS: dict[str, Any] = {
@@ -78,10 +78,20 @@ def take(cwd: str, session_id: str | None, tool: str, file_path: str, cfg: dict[
             "taken": time.strftime("%Y-%m-%dT%H:%M:%S"),
         }
     )
-    args = ["commit-tree", tree, "-m", msg] + (["-p", parent] if parent else [])
-    rc, commit, _ = git(args, top)
-    if rc != 0:
+    # the snapshot is gitvow's object, not the user's commit: give it a fixed identity so it never depends on git config
+    ident = {
+        **os.environ,
+        "GIT_AUTHOR_NAME": "gitvow",
+        "GIT_AUTHOR_EMAIL": "gitvow@localhost",
+        "GIT_COMMITTER_NAME": "gitvow",
+        "GIT_COMMITTER_EMAIL": "gitvow@localhost",
+    }
+    args = ["git", "commit-tree", tree, "-m", msg] + (["-p", parent] if parent else [])
+    r = subprocess.run(args, cwd=top, env=ident, capture_output=True, text=True, check=False)
+    if r.returncode != 0:
+        log_event(cwd, "snapshot_failed", {"step": "commit-tree", "error": r.stderr.strip()[:300]})
         return None
+    commit = r.stdout.strip()
     ref = ref_for(session_id, n)
     git(["update-ref", ref, commit], top)
     st["snapshots"] = n

{gitvow-0.5.0 → gitvow-0.6.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.5.0
+Version: 0.6.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.5.0 → gitvow-0.6.0}/src/gitvow.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ README.md
 pyproject.toml
 src/gitvow/__init__.py
 src/gitvow/__main__.py
+src/gitvow/adapters.py
 src/gitvow/cli.py
 src/gitvow/collect.py
 src/gitvow/default_policy.json
@@ -22,6 +23,7 @@ src/gitvow.egg-info/entry_points.txt
 src/gitvow.egg-info/requires.txt
 src/gitvow.egg-info/top_level.txt
 src/gitvow/hooks/__init__.py
+tests/test_adapters.py
 tests/test_collect.py
 tests/test_hooks.py
 tests/test_install_cli.py

gitvow-0.6.0/tests/test_adapters.py

@@ -0,0 +1,238 @@
+import io
+import json
+
+from gitvow import cli
+from gitvow.adapters import normalize, parse_apply_patch, respond
+from gitvow.install import install_repo, install_user, uninstall_repo, uninstall_user
+
+PATCH = """*** Begin Patch
+*** Update File: src/api/Orders.java
+@@
+-    return old;
++    @Path("/v1/orders/export")
++    return csv;
+*** Add File: docs/new.md
++# new
+*** Delete File: old.txt
+*** End Patch
+"""
+
+
+def test_parse_apply_patch():
+    files = parse_apply_patch(PATCH)
+    assert [f["file_path"] for f in files] == ["src/api/Orders.java", "docs/new.md", "old.txt"]
+    assert (
+        files[0]["op"] == "update"
+        and "/v1/orders/export" in files[0]["new_string"]
+        and "return old;" in files[0]["old_string"]
+    )
+    assert files[1]["op"] == "add" and files[1]["new_string"] == "# new"
+    assert files[2]["op"] == "delete"
+
+
+def test_codex_normalization_expands_patch_and_maps_events():
+    calls = normalize(
+        "codex",
+        "PreToolUse",
+        {"session_id": "c1", "cwd": "/r", "tool_name": "apply_patch", "tool_input": {"command": PATCH}},
+    )
+    assert [c[0] for c in calls] == ["PreToolUse"] * 3
+    assert calls[0][1]["tool_name"] == "Edit" and calls[0][1]["tool_input"]["file_path"] == "src/api/Orders.java"
+    bash = normalize(
+        "codex", "PreToolUse", {"session_id": "c1", "cwd": "/r", "tool_name": "Bash", "tool_input": {"command": "ls"}}
+    )
+    assert bash[0][1]["tool_name"] == "Bash" and bash[0][1]["tool_input"] == {"command": "ls"}
+    assert normalize("codex", "Stop", {"session_id": "c1", "cwd": "/r"})[0][0] == "Stop"
+    assert normalize("codex", "UserPromptSubmit", {}) == []
+
+
+def test_gemini_normalization():
+    c = normalize(
+        "gemini",
+        "BeforeTool",
+        {"session_id": "g1", "cwd": "/r", "tool_name": "run_shell_command", "tool_input": {"command": "git push -f"}},
+    )
+    assert c[0][0] == "PreToolUse" and c[0][1]["tool_name"] == "Bash"
+    c = normalize(
+        "gemini",
+        "AfterTool",
+        {
+            "session_id": "g1",
+            "cwd": "/r",
+            "tool_name": "write_file",
+            "tool_input": {"file_path": "a.py", "content": "x"},
+        },
+    )
+    assert c[0][0] == "PostToolUse" and c[0][1]["tool_name"] == "Write"
+    assert normalize("gemini", "SessionEnd", {"session_id": "g1", "cwd": "/r"})[0][0] == "Stop"
+
+
+def test_cursor_normalization_and_responses():
+    c = normalize(
+        "cursor", "beforeShellExecution", {"conversation_id": "cu1", "workspace_roots": ["/w"], "command": "rm -rf /"}
+    )
+    assert c[0][1] == {
+        "session_id": "cu1",
+        "transcript_path": "",
+        "cwd": "/w",
+        "hook_event_name": "PreToolUse",
+        "agent": "cursor",
+        "tool_name": "Bash",
+        "tool_input": {"command": "rm -rf /"},
+    }
+    c = normalize(
+        "cursor",
+        "afterFileEdit",
+        {
+            "conversation_id": "cu1",
+            "workspace_roots": ["/w"],
+            "file_path": "/w/a.py",
+            "edits": [{"old_string": "a", "new_string": "b"}, {"old_string": "", "new_string": '"/v1/x"'}],
+        },
+    )
+    assert c[0][0] == "PostToolUse" and c[0][1]["tool_input"]["new_string"] == 'b\n"/v1/x"'
+    c = normalize(
+        "cursor",
+        "beforeMCPExecution",
+        {
+            "conversation_id": "cu1",
+            "workspace_roots": ["/w"],
+            "tool_name": "delete_dashboard",
+            "mcp_server_name": "grafana",
+            "tool_input": {},
+        },
+    )
+    assert c[0][1]["tool_name"] == "mcp__grafana__delete_dashboard"
+    assert respond("cursor", 2, "BLOCKED by policy (force push).")[1] == json.dumps(
+        {
+            "permission": "deny",
+            "user_message": "BLOCKED by policy (force push).",
+            "agent_message": "BLOCKED by policy (force push).",
+        }
+    )
+    assert json.loads(respond("cursor", 2, "CONFIRMATION REQUIRED (x). Ask the user")[1])["permission"] == "ask"
+    assert json.loads(respond("cursor", 0, "")[1]) == {"permission": "allow"}
+    assert respond("codex", 2, "BLOCKED")[0] == 2 and respond("gemini", 0, "")[0] == 0
+
+
+def _run_hook(monkeypatch, capsys, agent, event, payload):
+    monkeypatch.setattr("sys.stdin", io.StringIO(json.dumps(payload)))
+    code = cli.main(["hook", "--agent", agent, event])
+    out = capsys.readouterr()
+    return code, out.out, out.err
+
+
+def test_cli_hook_per_agent_end_to_end(repo, home, monkeypatch, capsys):
+    monkeypatch.chdir(repo)
+    # codex: a destructive command is blocked with exit 2; a patch touching a gate file requires confirmation naming the file
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "codex",
+        "PreToolUse",
+        {"session_id": "c1", "cwd": str(repo), "tool_name": "Bash", "tool_input": {"command": "git push --force"}},
+    )
+    assert code == 2 and "BLOCKED" in err and out == ""
+    patch = "*** Begin Patch\n*** Update File: core/authz_rules.go\n+x\n*** Update File: README.md\n+y\n*** End Patch\n"
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "codex",
+        "PreToolUse",
+        {"session_id": "c1", "cwd": str(repo), "tool_name": "apply_patch", "tool_input": {"command": patch}},
+    )
+    assert code == 2 and "CONFIRMATION REQUIRED" in err and "[file: core/authz_rules.go]" in err
+    # gemini: allowed shell command exits 0 silently
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "gemini",
+        "BeforeTool",
+        {"session_id": "g1", "cwd": str(repo), "tool_name": "run_shell_command", "tool_input": {"command": "ls"}},
+    )
+    assert (code, out, err) == (0, "", "")
+    # cursor: JSON permission, ask for confirm-class, deny for deny-class, allow otherwise
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "cursor",
+        "beforeShellExecution",
+        {"conversation_id": "cu1", "workspace_roots": [str(repo)], "command": "kubectl apply -f x.yaml"},
+    )
+    assert code == 0 and json.loads(out)["permission"] == "ask"
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "cursor",
+        "beforeShellExecution",
+        {"conversation_id": "cu1", "workspace_roots": [str(repo)], "command": "terraform destroy"},
+    )
+    assert json.loads(out)["permission"] == "deny"
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "cursor",
+        "beforeShellExecution",
+        {"conversation_id": "cu1", "workspace_roots": [str(repo)], "command": "ls"},
+    )
+    assert json.loads(out) == {"permission": "allow"}
+    # cursor afterFileEdit takes a snapshot and records the blob like Claude Code's PostToolUse
+    (repo / "a.txt").write_text("cursor wrote this\n")
+    _run_hook(monkeypatch, capsys, "cursor", "sessionStart", {"conversation_id": "cu1", "workspace_roots": [str(repo)]})
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "cursor",
+        "afterFileEdit",
+        {
+            "conversation_id": "cu1",
+            "workspace_roots": [str(repo)],
+            "file_path": str(repo / "a.txt"),
+            "edits": [{"old_string": "a", "new_string": "cursor wrote this"}],
+        },
+    )
+    assert code == 0
+    from tests.conftest import git
+
+    assert git(repo, "for-each-ref", "--format=%(refname)", "refs/gitvow/snapshots/").endswith("/cu1/1")
+    # an event the adapter does not use is a no-op
+    assert _run_hook(monkeypatch, capsys, "gemini", "BeforeModel", {"session_id": "g1", "cwd": str(repo)})[0] == 0
+
+
+def test_install_per_agent_idempotent_and_reversible(home, repo):
+    for agent, rel, key in (
+        ("codex", ".codex/hooks.json", "PreToolUse"),
+        ("gemini", ".gemini/settings.json", "BeforeTool"),
+        ("cursor", ".cursor/hooks.json", "beforeShellExecution"),
+    ):
+        out = install_user(str(home), agent=agent)
+        install_user(str(home), agent=agent)
+        s = json.loads((home / rel).read_text())
+        assert len(s["hooks"][key]) == 1, agent
+        cmd = (
+            s["hooks"][key][0]["hooks"][0]["command"]
+            if "hooks" in s["hooks"][key][0]
+            else s["hooks"][key][0]["command"]
+        )
+        assert f"hook --agent {agent}" in cmd
+        if agent == "codex":
+            assert any("hooks = true" in x for x in out)
+        if agent == "cursor":
+            assert s["version"] == 1 and s["hooks"][key][0]["failClosed"] is True
+        if agent == "gemini":
+            assert s["hooks"][key][0]["hooks"][0]["name"] == "gitvow-BeforeTool"
+        uninstall_user(str(home), agent=agent)
+        assert not (home / rel).exists(), agent
+    # foreign entries survive
+    (home / ".cursor").mkdir(exist_ok=True)
+    (home / ".cursor" / "hooks.json").write_text(
+        json.dumps({"version": 1, "hooks": {"stop": [{"command": "mine.sh"}]}})
+    )
+    install_user(str(home), agent="cursor")
+    uninstall_user(str(home), agent="cursor")
+    assert json.loads((home / ".cursor" / "hooks.json").read_text())["hooks"]["stop"] == [{"command": "mine.sh"}]
+    # repo-level
+    install_repo(str(repo), agent="codex")
+    assert (repo / ".codex" / "hooks.json").exists()
+    uninstall_repo(str(repo), agent="codex")
+    assert not (repo / ".codex" / "hooks.json").exists()

{gitvow-0.5.0 → gitvow-0.6.0}/tests/test_snapshots.py

@@ -36,7 +36,7 @@ def test_snapshot_per_edit_with_head_parent_and_exclusions(repo, home, payload):
     assert git(repo, "status", "--short").count("\n") >= 0  # the real index was never touched
     assert "calc.py" not in git(repo, "diff", "--cached", "--name-only")
     st = json.loads((repo / ".git" / "gitvow-session.json").read_text())
-    assert st["snapshots"] == 2 and st["last_snapshot"] == "refs/gitvow/snapshots/sess-1/2"
+    assert st["snapshots"] == 3 and st["last_snapshot"] == "refs/gitvow/snapshots/sess-1/3"
     assert '"kind": "snapshot"' in (repo / ".git" / "gitvow-hooks.log").read_text()
 
 
@@ -126,11 +126,14 @@ def test_snapshot_in_repo_without_commits(tmp_path, home, payload):
     r = tmp_path / "fresh"
     r.mkdir()
     git(r, "init", "-q")
+    git(r, "config", "user.useConfigOnly", "true")  # no identity anywhere, as on a CI runner: snapshots must still work
     (r / "f.txt").write_text("first\n")
     p = payload("SessionStart")
     p["cwd"] = str(r)
     session_start(p, str(home))
     post_tool_use({**p, "tool_name": "Write", "tool_input": {"file_path": str(r / "f.txt")}}, str(home))
     ref = git(r, "for-each-ref", "--format=%(refname)", "refs/gitvow/snapshots/")
-    assert ref.endswith("/1") and git(r, "show", f"{ref}:f.txt") == "first"
+    log = (r / ".git" / "gitvow-hooks.log").read_text() if (r / ".git" / "gitvow-hooks.log").exists() else ""
+    assert ref.endswith("/1"), f"no snapshot ref; hook log: {log}"
+    assert git(r, "show", f"{ref}:f.txt") == "first"
     assert os.path.exists(r / ".git")