gitvow 0.7.1__tar.gz → 0.8.0__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gitvow"
-version = "0.7.1"
+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.1 → 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.1 → 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.1 → 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.1 → 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.7.1 → gitvow-0.8.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.7.1
+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.1 → 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()