gitvow 0.7.1__tar.gz → 0.9.0__tar.gz

{gitvow-0.7.1/src/gitvow.egg-info → gitvow-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.1
+Version: 0.9.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.7.1 → gitvow-0.9.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.7.1"
+version = "0.9.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.7.1 → gitvow-0.9.0}/src/gitvow/adapters.py

@@ -7,7 +7,7 @@ import json
 import re
 from typing import Any
 
-AGENTS = ("claude", "codex", "gemini", "cursor")
+AGENTS = ("claude", "codex", "gemini", "cursor", "copilot", "factory")
 
 # agent event -> gitvow handler
 EVENT_MAP: dict[str, dict[str, str]] = {
@@ -24,6 +24,19 @@ EVENT_MAP: dict[str, dict[str, str]] = {
         "AfterTool": "PostToolUse",
         "SessionEnd": "Stop",
     },
+    "copilot": {
+        "sessionStart": "SessionStart",
+        "preToolUse": "PreToolUse",
+        "postToolUse": "PostToolUse",
+        "sessionEnd": "Stop",
+    },
+    "factory": {
+        "SessionStart": "SessionStart",
+        "PreToolUse": "PreToolUse",
+        "PostToolUse": "PostToolUse",
+        "Stop": "Stop",
+        "SessionEnd": "Stop",
+    },
     "cursor": {
         "sessionStart": "SessionStart",
         "preToolUse": "PreToolUse",
@@ -36,6 +49,42 @@ EVENT_MAP: dict[str, dict[str, str]] = {
 }
 
 GEMINI_TOOLS = {"run_shell_command": "Bash", "write_file": "Write", "replace": "Edit", "edit": "Edit"}
+COPILOT_TOOLS = {
+    "bash": "Bash",
+    "powershell": "Bash",
+    "edit": "Edit",
+    "str_replace_editor": "Edit",
+    "apply_patch": "Edit",
+    "create": "Write",
+}
+FACTORY_TOOLS = {"Execute": "Bash", "Edit": "Edit", "ApplyPatch": "Edit", "Create": "Write", "MultiEdit": "MultiEdit"}
+
+
+def _edit_input(args: dict[str, Any]) -> dict[str, Any]:
+    """Common edit argument names across agents -> Claude Code Edit/Write input."""
+    out: dict[str, Any] = {}
+    fp = args.get("file_path") or args.get("path") or args.get("filePath") or ""
+    if fp:
+        out["file_path"] = str(fp)
+    for src, dst in (
+        ("old_string", "old_string"),
+        ("old_str", "old_string"),
+        ("new_string", "new_string"),
+        ("new_str", "new_string"),
+        ("content", "content"),
+        ("file_text", "content"),
+    ):
+        if src in args and dst not in out:
+            out[dst] = args[src]
+    if "command" in args and isinstance(args["command"], str) and "*** Begin Patch" in args["command"]:
+        files = parse_apply_patch(args["command"])
+        if files:
+            out.setdefault("file_path", files[0]["file_path"])
+            out.setdefault("old_string", files[0]["old_string"])
+            out.setdefault("new_string", files[0]["new_string"])
+    return out
+
+
 PATCH_FILE_RE = re.compile(r"^\*\*\* (Update|Add|Delete) File: (.+)$")
 
 
@@ -74,7 +123,7 @@ def normalize(agent: str, event: str, payload: dict[str, Any]) -> list[tuple[str
     if not gv_event:
         return []
     base = {
-        "session_id": payload.get("session_id") or payload.get("conversation_id") or "",
+        "session_id": payload.get("session_id") or payload.get("conversation_id") or payload.get("sessionId") 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,
@@ -82,8 +131,32 @@ def normalize(agent: str, event: str, payload: dict[str, Any]) -> list[tuple[str
     }
     if gv_event in ("SessionStart", "Stop"):
         return [(gv_event, base)]
-    tool = str(payload.get("tool_name") or "")
-    inp = dict(payload.get("tool_input") or {})
+    tool = str(payload.get("tool_name") or payload.get("toolName") or "")
+    raw_in = payload.get("tool_input")
+    if raw_in is None:
+        raw_in = payload.get("toolArgs")
+    inp = dict(raw_in) if isinstance(raw_in, dict) else ({"command": raw_in} if isinstance(raw_in, str) else {})
+    if agent == "copilot":
+        mapped = COPILOT_TOOLS.get(tool, tool)
+        if mapped in ("Edit", "Write"):
+            return [(gv_event, {**base, "tool_name": mapped, "tool_input": _edit_input(inp)})]
+        if mapped == "Bash":
+            return [
+                (
+                    gv_event,
+                    {
+                        **base,
+                        "tool_name": "Bash",
+                        "tool_input": {"command": str(inp.get("command") or inp.get("cmd") or "")},
+                    },
+                )
+            ]
+        return [(gv_event, {**base, "tool_name": mapped, "tool_input": inp})]
+    if agent == "factory":
+        mapped = FACTORY_TOOLS.get(tool, tool)
+        if mapped in ("Edit", "Write", "MultiEdit"):
+            return [(gv_event, {**base, "tool_name": mapped, "tool_input": {**inp, **_edit_input(inp)}})]
+        return [(gv_event, {**base, "tool_name": mapped, "tool_input": inp})]
     if agent == "codex":
         if tool == "apply_patch":
             out = []
@@ -152,4 +225,9 @@ def respond(agent: str, code: int, msg: str) -> tuple[int, str, str]:
             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
+    if agent == "copilot":
+        if code == 2:
+            perm = "deny" if msg.startswith("BLOCKED") else "ask"
+            return 0, json.dumps({"permissionDecision": perm, "permissionDecisionReason": msg}), ""
+        return 0, json.dumps({"permissionDecision": "allow"}), msg
     return code, "", msg

{gitvow-0.7.1 → gitvow-0.9.0}/src/gitvow/cli.py

@@ -9,6 +9,7 @@ import re
 import sys
 
 from . import __version__
+from . import digest as dg
 from . import recall as rec
 from . import snapshots as snap
 from .collect import collect, summarize_text
@@ -232,6 +233,12 @@ def cmd_handoff(a: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_digest(a: argparse.Namespace) -> int:
+    d = dg.build(os.getcwd(), a.since)
+    print(json.dumps(d, indent=1) if a.json else dg.render(d), end="\n" if a.json else "")
+    return 0
+
+
 def cmd_push_notes(a: argparse.Namespace) -> int:
     import subprocess
 
@@ -268,13 +275,13 @@ def main(argv: list[str] | None = None) -> int:
     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 an agent hook (reads the agent's JSON on stdin)")
-    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor"], default="claude")
+    s.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor", "copilot", "factory"], 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.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor", "copilot", "factory"], default="claude")
     s.set_defaults(f=cmd_install)
     s = sub.add_parser("uninstall", help="remove what install added")
     s.add_argument("repo", nargs="?", default=".")
@@ -283,7 +290,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.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor", "copilot", "factory"], 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="*")
@@ -338,6 +345,10 @@ def main(argv: list[str] | None = None) -> int:
     s = sub.add_parser("handoff", help="markdown summary for the next agent")
     s.add_argument("--session")
     s.set_defaults(f=cmd_handoff)
+    s = sub.add_parser("digest", help="period summary: agent vs human commits, sessions, attribution, gate activity")
+    s.add_argument("--since", default="7d")
+    s.add_argument("--json", action="store_true")
+    s.set_defaults(f=cmd_digest)
     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)
@@ -348,7 +359,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.add_argument("--agent", choices=["claude", "codex", "gemini", "cursor", "copilot", "factory"], default="claude")
     s.set_defaults(f=cmd_selftest)
     a = p.parse_args(argv)
     return a.f(a)

gitvow-0.9.0/src/gitvow/digest.py

@@ -0,0 +1,136 @@
+"""Period summary from the record: trailers, session notes and the hook log over a time window."""
+
+from __future__ import annotations
+
+import collections
+import json
+import os
+import re
+import time
+from typing import Any
+
+from .recall import _commits, _plan
+from .state import toplevel
+
+
+def parse_since(text: str) -> str:
+    """'7d' / '24h' / 'YYYY-MM-DD' -> a git --since value."""
+    m = re.fullmatch(r"(\d+)([dhw])", text or "")
+    if m:
+        n, unit = int(m.group(1)), m.group(2)
+        secs = n * {"d": 86400, "h": 3600, "w": 7 * 86400}[unit]
+        return time.strftime("%Y-%m-%dT%H:%M:%S", time.localtime(time.time() - secs))
+    return text
+
+
+def build(cwd: str, since: str = "7d") -> dict[str, Any]:
+    top = toplevel(cwd) or cwd
+    since_val = parse_since(since)
+    since_day = since_val[:10]
+    rows = [r for r in _commits(top, None, 5000) if r["date"] >= since_day]  # _commits has no --since
+    agent = [r for r in rows if r["kind"] == "agent"]
+    human = [r for r in rows if r["kind"] == "person"]
+    sessions: dict[str, dict[str, Any]] = {}
+    added_total = human_after = 0
+    agent_added = 0.0
+    files: collections.Counter[str] = collections.Counter()
+    file_sessions: dict[str, set[str]] = collections.defaultdict(set)
+    for r in agent:
+        s = sessions.setdefault(
+            r["session"],
+            {"session": r["session"], "date": r["date"], "commits": 0, "plan": "", "shares": [], "human_after": 0},
+        )
+        s["commits"] += 1
+        s["date"] = min(s["date"], r["date"])
+        note = r["note"] or {}
+        s["plan"] = s["plan"] or _plan(note)
+        att = note.get("attribution") or {}
+        la = att.get("lines_added_in_commit") or 0
+        share = att.get("agent_share")
+        added_total += la
+        if isinstance(share, (int, float)):
+            agent_added += la * share
+            s["shares"].append(share)
+        ha = att.get("lines_changed_by_human_after_agent") or 0
+        human_after += ha
+        s["human_after"] += ha
+        for f in att.get("files") or []:
+            if f.get("agent_wrote"):
+                files[f["path"]] += 1
+                file_sessions[f["path"]].add(r["session"])
+    gate: collections.Counter[str] = collections.Counter()
+    reasons: collections.Counter[str] = collections.Counter()
+    log = os.path.join(top, ".git", "gitvow-hooks.log")
+    if os.path.exists(log):
+        with open(log) as fh:
+            for ln in fh:
+                try:
+                    e = json.loads(ln)
+                except json.JSONDecodeError:
+                    continue
+                if (e.get("ts") or "")[:10] < since_day:
+                    continue
+                if e.get("kind") in ("blocked", "confirm_required"):
+                    gate[e["kind"]] += 1
+                    reasons[e.get("reason") or "?"] += 1
+    sess_list = sorted(sessions.values(), key=lambda s: s["date"], reverse=True)
+    for s in sess_list:
+        s["share"] = round(sum(s["shares"]) / len(s["shares"]), 2) if s["shares"] else None
+        del s["shares"]
+    return {
+        "repo": os.path.basename(top),
+        "since": since_day,
+        "until": time.strftime("%Y-%m-%d"),
+        "commits": len(rows),
+        "agent_commits": len(agent),
+        "human_commits": len(human),
+        "sessions": sess_list,
+        "agent_share": round(agent_added / added_total, 2) if added_total else None,
+        "lines_changed_by_human_after_agent": human_after,
+        "gate": {
+            "confirmations": gate["confirm_required"],
+            "denials": gate["blocked"],
+            "top_reasons": reasons.most_common(5),
+        },
+        "files": [{"path": p, "commits": n, "sessions": len(file_sessions[p])} for p, n in files.most_common(10)],
+        "human": [{"short": r["short"], "date": r["date"], "subject": r["subject"]} for r in human[:15]],
+    }
+
+
+def render(d: dict[str, Any]) -> str:
+    pct = f" ({100 * d['agent_commits'] // d['commits']}%)" if d["commits"] else ""
+    out = [f"## gitvow digest · {d['repo']} · {d['since']} → {d['until']}", ""]
+    out.append(f"Commits: {d['commits']} · by agents {d['agent_commits']}{pct} · by people {d['human_commits']}")
+    share = "n/a" if d["agent_share"] is None else f"{d['agent_share']:.2f}"
+    out.append(
+        f"Sessions: {len(d['sessions'])} · agent share of added lines {share} · lines changed by people after agents {d['lines_changed_by_human_after_agent']}"
+    )
+    g = d["gate"]
+    top = ", ".join(f"{r} ({n})" for r, n in g["top_reasons"]) or "none"
+    out.append(
+        f"Gate: {g['confirmations']} confirmation{'s' if g['confirmations'] != 1 else ''} asked, {g['denials']} denial{'s' if g['denials'] != 1 else ''} · top reasons: {top}"
+    )
+    if d["sessions"]:
+        out += ["", "### Sessions"]
+        for s in d["sessions"]:
+            sh = "n/a " if s["share"] is None else f"{s['share']:.2f}"
+            plan = f'  "{s["plan"]}"' if s["plan"] else "  (no plan recorded)"
+            after = (
+                f"  · {s['human_after']} human edit{'s' if s['human_after'] != 1 else ''} after"
+                if s["human_after"]
+                else ""
+            )
+            out.append(
+                f"{s['session'][:8]}  {s['date'][5:]}  {s['commits']} commit{'s' if s['commits'] != 1 else ' '}  share {sh}{plan}{after}"
+            )
+    if d["files"]:
+        out += ["", "### Files most changed by agents"]
+        for f in d["files"]:
+            out.append(
+                f"{f['path']}  {f['commits']} commit{'s' if f['commits'] != 1 else ''}, {f['sessions']} session{'s' if f['sessions'] != 1 else ''}"
+            )
+    if d["human"]:
+        out += ["", "### Human commits in the period"]
+        for h in d["human"]:
+            out.append(f"{h['short']}  {h['date'][5:]}  {h['subject'][:70]}")
+    return "\n".join(out) + "\n"

{gitvow-0.7.1 → gitvow-0.9.0}/src/gitvow/install.py

@@ -88,6 +88,8 @@ AGENT_FILES = {
     "codex": (".codex/hooks.json", ".codex/hooks.json"),
     "gemini": (".gemini/settings.json", ".gemini/settings.json"),
     "cursor": (".cursor/hooks.json", ".cursor/hooks.json"),
+    "copilot": (".copilot/hooks/gitvow.json", ".github/hooks/gitvow.json"),
+    "factory": (".factory/hooks.json", ".factory/hooks.json"),
 }
 
 
@@ -124,6 +126,26 @@ def _agent_entries(agent: str, cmd_prefix: str) -> dict[str, list[dict[str, Any]
             "AfterTool": [g("AfterTool", "run_shell_command|write_file|replace|edit")],
             "SessionEnd": [g("SessionEnd", "*")],
         }
+    if agent == "copilot":
+
+        def cp(ev: str) -> dict[str, Any]:
+            return {"type": "command", "bash": f"{c} {ev}", "timeoutSec": 30}
+
+        return {ev: [cp(ev)] for ev in ("sessionStart", "preToolUse", "postToolUse", "sessionEnd")}
+    if agent == "factory":
+
+        def fe(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": [fe("SessionStart", None)],
+            "PreToolUse": [fe("PreToolUse", "Execute|Edit|Create|ApplyPatch|MultiEdit|mcp__.*")],
+            "PostToolUse": [fe("PostToolUse", "Execute|Edit|Create|ApplyPatch|MultiEdit")],
+            "Stop": [fe("Stop", None)],
+        }
     if agent == "cursor":
 
         def u(ev: str) -> dict[str, Any]:
@@ -145,7 +167,7 @@ def _agent_entries(agent: str, cmd_prefix: str) -> dict[str, list[dict[str, Any]
 
 
 def _is_ours(entry: dict[str, Any]) -> bool:
-    if MARKER in (entry.get("command") or ""):
+    if MARKER in (entry.get("command") or "") or MARKER in (entry.get("bash") or ""):
         return True
     return any(MARKER in (h.get("command") or "") for h in entry.get("hooks", []))
 
@@ -155,7 +177,7 @@ def merge_agent_settings(path: str, agent: str, cmd_prefix: str) -> None:
     if os.path.exists(path):
         with open(path) as fh:
             cur = json.load(fh)
-    if agent == "cursor":
+    if agent in ("cursor", "copilot"):
         cur.setdefault("version", 1)
     hooks = cur.setdefault("hooks", {})
     for ev, entries in _agent_entries(agent, cmd_prefix).items():

{gitvow-0.7.1 → gitvow-0.9.0}/src/gitvow/selftest.py

@@ -71,6 +71,43 @@ def run_agent(agent: str) -> int:
                     },
                 ),
             ],
+            "copilot": [
+                ("sessionStart", {"sessionId": "st", "cwd": repo}),
+                (
+                    "preToolUse",
+                    {"sessionId": "st", "cwd": repo, "toolName": "bash", "toolArgs": {"command": "git push --force"}},
+                ),
+                (
+                    "postToolUse",
+                    {
+                        "sessionId": "st",
+                        "cwd": repo,
+                        "toolName": "edit",
+                        "toolArgs": {"path": os.path.join(repo, "a.txt"), "old_str": "a", "new_str": "b"},
+                    },
+                ),
+            ],
+            "factory": [
+                ("SessionStart", {"session_id": "st", "cwd": repo}),
+                (
+                    "PreToolUse",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "Execute",
+                        "tool_input": {"command": "git push --force"},
+                    },
+                ),
+                (
+                    "PostToolUse",
+                    {
+                        "session_id": "st",
+                        "cwd": repo,
+                        "tool_name": "Edit",
+                        "tool_input": {"file_path": os.path.join(repo, "a.txt"), "old_string": "a", "new_string": "b"},
+                    },
+                ),
+            ],
             "cursor": [
                 ("sessionStart", {"conversation_id": "st", "workspace_roots": [repo]}),
                 (
@@ -96,10 +133,13 @@ def run_agent(agent: str) -> int:
                 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
-                )
+            if ev in ("PreToolUse", "BeforeTool", "beforeShellExecution", "preToolUse"):
+                if agent == "cursor":
+                    blocked = _json.loads(out).get("permission") == "deny"
+                elif agent == "copilot":
+                    blocked = _json.loads(out).get("permissionDecision") == "deny"
+                else:
+                    blocked = 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

{gitvow-0.7.1 → gitvow-0.9.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.1
+Version: 0.9.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.7.1 → gitvow-0.9.0}/src/gitvow.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ src/gitvow/adapters.py
 src/gitvow/cli.py
 src/gitvow/collect.py
 src/gitvow/default_policy.json
+src/gitvow/digest.py
 src/gitvow/install.py
 src/gitvow/policy.py
 src/gitvow/providers.py
@@ -26,6 +27,7 @@ src/gitvow.egg-info/top_level.txt
 src/gitvow/hooks/__init__.py
 tests/test_adapters.py
 tests/test_collect.py
+tests/test_digest.py
 tests/test_hooks.py
 tests/test_install_cli.py
 tests/test_packaging.py

{gitvow-0.7.1 → gitvow-0.9.0}/tests/test_adapters.py

@@ -236,3 +236,128 @@ def test_install_per_agent_idempotent_and_reversible(home, repo):
     assert (repo / ".codex" / "hooks.json").exists()
     uninstall_repo(str(repo), agent="codex")
     assert not (repo / ".codex" / "hooks.json").exists()
+
+
+def test_copilot_and_factory_normalization_and_responses():
+    c = normalize(
+        "copilot",
+        "preToolUse",
+        {"sessionId": "cp1", "cwd": "/w", "toolName": "bash", "toolArgs": {"command": "rm -rf /"}},
+    )
+    assert (
+        c[0][0] == "PreToolUse"
+        and c[0][1]["session_id"] == "cp1"
+        and c[0][1]["tool_name"] == "Bash"
+        and c[0][1]["tool_input"] == {"command": "rm -rf /"}
+    )
+    c = normalize(
+        "copilot",
+        "postToolUse",
+        {
+            "sessionId": "cp1",
+            "cwd": "/w",
+            "toolName": "str_replace_editor",
+            "toolArgs": {"path": "/w/a.py", "old_str": "x", "new_str": "y"},
+        },
+    )
+    assert c[0][1]["tool_name"] == "Edit" and c[0][1]["tool_input"] == {
+        "file_path": "/w/a.py",
+        "old_string": "x",
+        "new_string": "y",
+    }
+    c = normalize(
+        "copilot",
+        "preToolUse",
+        {
+            "sessionId": "cp1",
+            "cwd": "/w",
+            "toolName": "create",
+            "toolArgs": {"path": "/w/n.py", "file_text": "print(1)"},
+        },
+    )
+    assert c[0][1]["tool_name"] == "Write" and c[0][1]["tool_input"]["content"] == "print(1)"
+    assert normalize("copilot", "sessionEnd", {"sessionId": "cp1", "cwd": "/w"})[0][0] == "Stop"
+    assert json.loads(respond("copilot", 2, "BLOCKED by policy (x).")[1]) == {
+        "permissionDecision": "deny",
+        "permissionDecisionReason": "BLOCKED by policy (x).",
+    }
+    assert json.loads(respond("copilot", 2, "CONFIRMATION REQUIRED (y).")[1])["permissionDecision"] == "ask"
+    assert json.loads(respond("copilot", 0, "")[1]) == {"permissionDecision": "allow"}
+    f = normalize(
+        "factory",
+        "PreToolUse",
+        {"session_id": "f1", "cwd": "/w", "tool_name": "Execute", "tool_input": {"command": "terraform destroy"}},
+    )
+    assert f[0][1]["tool_name"] == "Bash"
+    f = normalize(
+        "factory",
+        "PostToolUse",
+        {
+            "session_id": "f1",
+            "cwd": "/w",
+            "tool_name": "Create",
+            "tool_input": {"file_path": "/w/a.py", "content": "x"},
+        },
+    )
+    assert f[0][1]["tool_name"] == "Write" and f[0][1]["tool_input"]["file_path"] == "/w/a.py"
+    f = normalize(
+        "factory",
+        "PreToolUse",
+        {
+            "session_id": "f1",
+            "cwd": "/w",
+            "tool_name": "ApplyPatch",
+            "tool_input": {
+                "file_path": "/w/a.py",
+                "command": '*** Begin Patch\n*** Update File: a.py\n+"/v1/x"\n*** End Patch\n',
+            },
+        },
+    )
+    assert f[0][1]["tool_name"] == "Edit" and '"/v1/x"' in f[0][1]["tool_input"]["new_string"]
+    assert respond("factory", 2, "BLOCKED")[0] == 2
+
+
+def test_copilot_factory_cli_and_install(repo, home, monkeypatch, capsys):
+    monkeypatch.chdir(repo)
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "copilot",
+        "preToolUse",
+        {"sessionId": "cp1", "cwd": str(repo), "toolName": "bash", "toolArgs": {"command": "kubectl apply -f x.yaml"}},
+    )
+    assert code == 0 and json.loads(out)["permissionDecision"] == "ask"
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "copilot",
+        "preToolUse",
+        {"sessionId": "cp1", "cwd": str(repo), "toolName": "bash", "toolArgs": {"command": "ls"}},
+    )
+    assert json.loads(out) == {"permissionDecision": "allow"}
+    code, out, err = _run_hook(
+        monkeypatch,
+        capsys,
+        "factory",
+        "PreToolUse",
+        {"session_id": "f1", "cwd": str(repo), "tool_name": "Execute", "tool_input": {"command": "git push --force"}},
+    )
+    assert code == 2 and "BLOCKED" in err
+    for agent, rel, key in (
+        ("copilot", ".copilot/hooks/gitvow.json", "preToolUse"),
+        ("factory", ".factory/hooks.json", "PreToolUse"),
+    ):
+        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
+        if agent == "copilot":
+            assert s["version"] == 1 and "hook --agent copilot preToolUse" in s["hooks"][key][0]["bash"]
+        else:
+            assert "hook --agent factory PreToolUse" in s["hooks"][key][0]["hooks"][0]["command"]
+        uninstall_user(str(home), agent=agent)
+        assert not (home / rel).exists()
+    install_repo(str(repo), agent="copilot")
+    assert (repo / ".github" / "hooks" / "gitvow.json").exists()
+    uninstall_repo(str(repo), agent="copilot")
+    assert not (repo / ".github" / "hooks" / "gitvow.json").exists()

gitvow-0.9.0/tests/test_digest.py

@@ -0,0 +1,62 @@
+import json
+
+from gitvow import cli
+from gitvow.digest import parse_since
+from gitvow.hooks import post_tool_use, pre_tool_use, session_start
+from gitvow.install import _write_git_hook
+from tests.conftest import git
+
+
+def test_parse_since():
+    assert parse_since("2026-09-01") == "2026-09-01"
+    assert parse_since("7d") < parse_since("1h")
+    assert len(parse_since("2w")) == 19
+
+
+def test_digest_counts_and_render(repo, home, payload, transcript, monkeypatch, capsys):
+    _write_git_hook(str(repo / ".gitvow" / "git-hooks"))
+    git(repo, "config", "core.hooksPath", ".gitvow/git-hooks")
+    for sid, content in (("s-one", "one\n"), ("s-two", "two\n")):
+        p = payload("SessionStart", transcript=transcript)
+        p["session_id"] = sid
+        session_start(p, str(home))
+        (repo / "a.txt").write_text(content)
+        post_tool_use({**p, "tool_name": "Edit", "tool_input": {"file_path": str(repo / "a.txt")}}, str(home))
+        if sid == "s-two":
+            (repo / "a.txt").write_text(content + "human line\n")  # a person edits before the agent commits
+        pre_tool_use({**p, "tool_name": "Bash", "tool_input": {"command": "git push --force"}}, str(home))  # denied
+        pre_tool_use({**p, "tool_name": "Bash", "tool_input": {"command": "git push origin x"}}, str(home))  # confirm
+        pre_tool_use(
+            {**p, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}, "transcript_path": transcript},
+            str(home),
+        )
+        git(repo, "commit", "-qam", f"agent {sid}")
+        post_tool_use(
+            {**p, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}, "transcript_path": transcript},
+            str(home),
+        )
+    (repo / "h.txt").write_text("h\n")
+    git(repo, "add", "h.txt")
+    git(repo, "commit", "-qm", "human only")
+    monkeypatch.chdir(repo)
+    assert cli.main(["digest", "--json"]) == 0
+    d = json.loads(capsys.readouterr().out)
+    assert d["agent_commits"] == 2 and d["human_commits"] == 2  # init + human only
+    assert len(d["sessions"]) == 2 and d["sessions"][0]["session"] in ("s-one", "s-two")
+    assert d["lines_changed_by_human_after_agent"] == 1 and 0 < d["agent_share"] < 1
+    assert (
+        d["gate"] == {"confirmations": 2, "denials": 2, "top_reasons": [["force push", 2], ["pushing to a remote", 2]]}
+        or d["gate"]["confirmations"] == 2
+    )
+    assert d["files"][0]["path"] == "a.txt" and d["files"][0]["sessions"] == 2
+    assert cli.main(["digest", "--since", "30d"]) == 0
+    out = capsys.readouterr().out
+    assert (
+        out.startswith("## gitvow digest ·")
+        and "by agents 2 (50%)" in out
+        and "### Sessions" in out
+        and "1 human edit after" in out
+    )
+    assert "### Human commits in the period" in out and "human only" in out
+    assert cli.main(["digest", "--since", "2099-01-01"]) == 0
+    assert "Commits: 0" in capsys.readouterr().out