gitvow 0.7.0__tar.gz → 0.8.0__tar.gz

{gitvow-0.7.0/src/gitvow.egg-info → gitvow-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.0
+Version: 0.8.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.0 → gitvow-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.7.0"
+version = "0.8.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.0 → gitvow-0.8.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.0 → gitvow-0.8.0}/src/gitvow/cli.py

@@ -268,13 +268,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 +283,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="*")
@@ -348,7 +348,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.7.0 → gitvow-0.8.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.0 → gitvow-0.8.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.8.0/src/gitvow/transcript.py

@@ -0,0 +1,187 @@
+"""Structural, redacted summary of an agent transcript (Claude Code JSONL). Tool output is never read."""
+
+from __future__ import annotations
+
+import json
+import os
+from collections.abc import Iterable
+from typing import Any
+
+from .redact import redact
+
+
+def _detect(first: dict[str, Any]) -> str:
+    """Which agent wrote this transcript: claude (default), codex (rollout records), gemini (chat recording)."""
+    t = first.get("type")
+    if t in ("session_meta", "response_item", "event_msg", "turn_context", "compacted") and "payload" in first:
+        return "codex"
+    if "sessionId" in first and "projectHash" in first:
+        return "gemini"
+    if first.get("type") in ("user", "gemini", "info", "error") and "content" in first and "message" not in first:
+        return "gemini"
+    return "claude"
+
+
+def _text_of(content: Any) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        parts = []
+        for c in content:
+            if isinstance(c, dict):
+                if c.get("type") in ("text", "output_text", "input_text") and c.get("text"):
+                    parts.append(str(c["text"]))
+                elif "text" in c and isinstance(c["text"], str):
+                    parts.append(c["text"])
+            elif isinstance(c, str):
+                parts.append(c)
+        return "\n".join(parts)
+    return ""
+
+
+def _patch_files(text: str) -> list[str]:
+    import re
+
+    return re.findall(r"^\*\*\* (?:Update|Add|Delete) File: (.+)$", text or "", re.M)
+
+
+def _codex_tool(name: str, arguments: Any) -> tuple[str, str, list[str]]:
+    """Codex function names -> (gitvow tool, brief argument, files written)."""
+    args: dict[str, Any] = {}
+    if isinstance(arguments, str):
+        try:
+            args = json.loads(arguments) if arguments.strip().startswith("{") else {"input": arguments}
+        except json.JSONDecodeError:
+            args = {"input": arguments}
+    elif isinstance(arguments, dict):
+        args = arguments
+    if name in ("exec_command", "shell", "container.exec", "local_shell"):
+        cmd = args.get("cmd") or args.get("command") or ""
+        cmd = " ".join(cmd) if isinstance(cmd, list) else str(cmd)
+        return "Bash", cmd, []
+    if name == "apply_patch":
+        patch = str(args.get("input") or args.get("patch") or args.get("command") or "")
+        files = _patch_files(patch)
+        return "Edit", files[0] if files else "apply_patch", files
+    return name, json.dumps(args)[:160] if args else "", []
+
+
+def _gemini_tool(name: str, args: Any) -> tuple[str, str, list[str]]:
+    a = args if isinstance(args, dict) else {}
+    if name == "run_shell_command":
+        return "Bash", str(a.get("command") or ""), []
+    if name in ("write_file", "replace", "edit"):
+        fp = str(a.get("file_path") or a.get("path") or "")
+        return ("Write" if name == "write_file" else "Edit"), fp, [fp] if fp else []
+    return name, json.dumps(a)[:160] if a else "", []
+
+
+def summarize(path: str | None, max_tools: int = 500, rules: Iterable[tuple[str, str]] = ()) -> dict[str, Any]:
+    """Structural summary of a transcript. Reads Claude Code, Codex and Gemini CLI formats; tool output is never read."""
+    out: dict[str, Any] = {
+        "turns": 0,
+        "tool_calls": [],
+        "last_assistant_text": "",
+        "files_written": [],
+        "format": "claude",
+    }
+    if not path or not os.path.exists(path):
+        return out
+    rules = list(rules)
+    written: set[str] = set()
+    fmt: str | None = None
+    with open(path, errors="ignore") as fh:
+        for line in fh:
+            try:
+                ev = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if not isinstance(ev, dict):
+                continue
+            if fmt is None:
+                fmt = _detect(ev)
+                out["format"] = fmt
+            if fmt == "codex":
+                _codex_event(ev, out, written, rules, max_tools)
+            elif fmt == "gemini":
+                _gemini_event(ev, out, written, rules, max_tools)
+            else:
+                _claude_event(ev, out, written, rules, max_tools)
+    out["files_written"] = sorted(written)
+    return out
+
+
+def _add_tool(out: dict[str, Any], tool: str, brief: str, rules: list[tuple[str, str]], max_tools: int) -> None:
+    if len(out["tool_calls"]) < max_tools:
+        out["tool_calls"].append({"tool": tool, "arg": redact(str(brief), rules)[:160]})
+
+
+def _claude_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    msg = ev.get("message") or {}
+    role = msg.get("role") or ev.get("type")
+    content = msg.get("content")
+    if role != "assistant":
+        return
+    out["turns"] += 1
+    if isinstance(content, str):
+        if content.strip():
+            out["last_assistant_text"] = redact(content, rules)[:600]
+        return
+    if not isinstance(content, list):
+        return
+    for c in content:
+        if not isinstance(c, dict):
+            continue
+        if c.get("type") == "tool_use":
+            inp = c.get("input") or {}
+            brief = inp.get("command") or inp.get("file_path") or inp.get("query") or inp.get("pattern") or ""
+            _add_tool(out, str(c.get("name")), brief, rules, max_tools)
+            if c.get("name") in ("Edit", "Write", "MultiEdit", "NotebookEdit") and inp.get("file_path"):
+                written.add(str(inp["file_path"]))
+        elif c.get("type") == "text" and str(c.get("text", "")).strip():
+            out["last_assistant_text"] = redact(c["text"], rules)[:600]
+
+
+def _codex_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    t, p = ev.get("type"), ev.get("payload") or {}
+    if not isinstance(p, dict):
+        return
+    if t == "response_item":
+        pt = p.get("type")
+        if pt == "message" and p.get("role") == "assistant":
+            out["turns"] += 1
+            text = _text_of(p.get("content"))
+            if text.strip():
+                out["last_assistant_text"] = redact(text, rules)[:600]
+        elif pt in ("function_call", "custom_tool_call", "local_shell_call"):
+            name = str(p.get("name") or ("local_shell" if pt == "local_shell_call" else ""))
+            arguments = p.get("arguments") if pt == "function_call" else (p.get("input") or p.get("action") or "")
+            tool, brief, files = _codex_tool(name, arguments)
+            _add_tool(out, tool, brief, rules, max_tools)
+            written.update(files)
+    elif t == "event_msg":
+        pt = p.get("type")
+        if pt == "agent_message" and p.get("message"):
+            out["turns"] += 1
+            out["last_assistant_text"] = redact(str(p["message"]), rules)[:600]
+
+
+def _gemini_event(
+    ev: dict[str, Any], out: dict[str, Any], written: set[str], rules: list[tuple[str, str]], max_tools: int
+) -> None:
+    if ev.get("type") != "gemini":
+        return
+    out["turns"] += 1
+    text = _text_of(ev.get("content"))
+    if text.strip():
+        out["last_assistant_text"] = redact(text, rules)[:600]
+    for tc in ev.get("toolCalls") or []:
+        if not isinstance(tc, dict):
+            continue
+        tool, brief, files = _gemini_tool(str(tc.get("name") or ""), tc.get("args"))
+        _add_tool(out, tool, brief, rules, max_tools)
+        written.update(files)

{gitvow-0.7.0 → gitvow-0.8.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.0
+Version: 0.8.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.0 → gitvow-0.8.0}/src/gitvow.egg-info/SOURCES.txt

@@ -34,4 +34,5 @@ tests/test_providers.py
 tests/test_recall.py
 tests/test_redact.py
 tests/test_report.py
-tests/test_snapshots.py
+tests/test_snapshots.py
+tests/test_transcript_formats.py

{gitvow-0.7.0 → gitvow-0.8.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.8.0/tests/test_transcript_formats.py

@@ -0,0 +1,128 @@
+import json
+
+from gitvow.transcript import summarize
+
+CODEX = [
+    {
+        "timestamp": "t",
+        "type": "session_meta",
+        "payload": {"id": "abc", "cwd": "/r", "cli_version": "0.130.0", "git": {"branch": "main"}},
+    },
+    {"timestamp": "t", "type": "turn_context", "payload": {"cwd": "/r", "model": "gpt-5"}},
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "fix add"}]},
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "message",
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "output_text",
+                    "text": "I will fix add() in calc.py; token ghp_ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 stays out.",
+                }
+            ],
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "function_call",
+            "name": "exec_command",
+            "arguments": json.dumps({"cmd": ["git", "status"]}),
+            "call_id": "c1",
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {"type": "function_call_output", "call_id": "c1", "output": "clean SECRET=hunter2 (never read)"},
+    },
+    {
+        "timestamp": "t",
+        "type": "response_item",
+        "payload": {
+            "type": "custom_tool_call",
+            "name": "apply_patch",
+            "input": "*** Begin Patch\n*** Update File: calc.py\n-    return a - b\n+    return a + b\n*** End Patch\n",
+            "call_id": "c2",
+        },
+    },
+    {
+        "timestamp": "t",
+        "type": "event_msg",
+        "payload": {"type": "agent_message", "message": "Done: fixed add() in calc.py."},
+    },
+    {
+        "timestamp": "t",
+        "type": "event_msg",
+        "payload": {"type": "token_count", "info": {"total_token_usage": {"input_tokens": 10}}},
+    },
+]
+
+GEMINI = [
+    {"sessionId": "g1", "projectHash": "h", "startTime": "t", "lastUpdated": "t", "kind": "main"},
+    {"id": "m1", "timestamp": "t", "type": "user", "content": "fix add"},
+    {
+        "id": "m2",
+        "timestamp": "t",
+        "type": "gemini",
+        "content": [{"text": "Fixing add() in calc.py now."}],
+        "model": "gemini-2.5-pro",
+        "toolCalls": [
+            {"id": "t1", "name": "run_shell_command", "args": {"command": "git status"}, "status": "success"},
+            {
+                "id": "t2",
+                "name": "replace",
+                "args": {"file_path": "/r/calc.py", "old_string": "a - b", "new_string": "a + b"},
+                "status": "success",
+            },
+            {"id": "t3", "name": "write_file", "args": {"file_path": "/r/new.py", "content": "x"}, "status": "success"},
+        ],
+    },
+    {"$set": {"lastUpdated": "t2"}},
+    {"id": "m3", "timestamp": "t", "type": "gemini", "content": "All done in calc.py and new.py."},
+]
+
+
+def _write(tmp_path, name, rows):
+    p = tmp_path / name
+    p.write_text("\n".join(json.dumps(r) for r in rows) + "\n")
+    return str(p)
+
+
+def test_codex_rollout_is_read(tmp_path):
+    s = summarize(_write(tmp_path, "rollout.jsonl", CODEX))
+    assert s["format"] == "codex" and s["turns"] == 2
+    assert [t["tool"] for t in s["tool_calls"]] == ["Bash", "Edit"]
+    assert s["tool_calls"][0]["arg"] == "git status" and s["tool_calls"][1]["arg"] == "calc.py"
+    assert s["files_written"] == ["calc.py"]
+    assert s["last_assistant_text"] == "Done: fixed add() in calc.py."
+    assert "hunter2" not in json.dumps(s)  # tool output is never read
+
+
+def test_gemini_chat_recording_is_read(tmp_path):
+    s = summarize(_write(tmp_path, "session-1.jsonl", GEMINI))
+    assert s["format"] == "gemini" and s["turns"] == 2
+    assert [t["tool"] for t in s["tool_calls"]] == ["Bash", "Edit", "Write"]
+    assert sorted(s["files_written"]) == ["/r/calc.py", "/r/new.py"]
+    assert s["last_assistant_text"] == "All done in calc.py and new.py."
+
+
+def test_claude_format_still_default(transcript):
+    s = summarize(transcript)
+    assert (
+        s["format"] == "claude"
+        and s["tool_calls"][0]["tool"] == "Bash"
+        and "[github-token]" in s["last_assistant_text"]
+    )
+
+
+def test_redaction_applies_to_all_formats(tmp_path):
+    s = summarize(_write(tmp_path, "rollout.jsonl", CODEX[:4]))
+    assert "[github-token]" in s["last_assistant_text"] and "ghp_" not in s["last_assistant_text"]

gitvow-0.7.0/src/gitvow/transcript.py

@@ -1,49 +0,0 @@
-"""Structural, redacted summary of an agent transcript (Claude Code JSONL). Tool output is never read."""
-
-from __future__ import annotations
-
-import json
-import os
-from collections.abc import Iterable
-from typing import Any
-
-from .redact import redact
-
-
-def summarize(path: str | None, max_tools: int = 500, rules: Iterable[tuple[str, str]] = ()) -> dict[str, Any]:
-    out: dict[str, Any] = {"turns": 0, "tool_calls": [], "last_assistant_text": "", "files_written": []}
-    if not path or not os.path.exists(path):
-        return out
-    written: set[str] = set()
-    rules = list(rules)
-    with open(path, errors="ignore") as fh:
-        for line in fh:
-            try:
-                ev = json.loads(line)
-            except json.JSONDecodeError:
-                continue
-            msg = ev.get("message") or {}
-            role = msg.get("role") or ev.get("type")
-            content = msg.get("content")
-            if role != "assistant":
-                continue
-            out["turns"] += 1
-            if isinstance(content, str):
-                if content.strip():
-                    out["last_assistant_text"] = redact(content, rules)[:600]
-                continue
-            if not isinstance(content, list):
-                continue
-            for c in content:
-                if not isinstance(c, dict):
-                    continue
-                if c.get("type") == "tool_use" and len(out["tool_calls"]) < max_tools:
-                    inp = c.get("input") or {}
-                    brief = inp.get("command") or inp.get("file_path") or inp.get("query") or inp.get("pattern") or ""
-                    out["tool_calls"].append({"tool": c.get("name"), "arg": redact(str(brief), rules)[:160]})
-                    if c.get("name") in ("Edit", "Write", "MultiEdit", "NotebookEdit") and inp.get("file_path"):
-                        written.add(str(inp["file_path"]))
-                elif c.get("type") == "text" and str(c.get("text", "")).strip():
-                    out["last_assistant_text"] = redact(c["text"], rules)[:600]
-    out["files_written"] = sorted(written)
-    return out