gitvow 0.13.0__tar.gz → 0.13.2__tar.gz

{gitvow-0.13.0/src/gitvow.egg-info → gitvow-0.13.2}/PKG-INFO

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

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

@@ -97,18 +97,57 @@ def _check_agent(agent: str) -> int:
 
 
 def cmd_install(a: argparse.Namespace) -> int:
-    agent = a.agent or "claude"
-    if _check_agent(agent):
-        return 1
-    if a.user:
-        done = install_user(os.path.expanduser("~"), agent=agent)
+    """Without --agent, configure every agent found on this machine: not passing a flag should not
+    silently leave an agent ungated."""
+    from .install import detect_agents
+
+    home = os.path.expanduser("~")
+    repo = os.path.abspath(a.repo)
+    if a.agent:
+        agents, detected = [a.agent], False
     else:
-        done = install_repo(os.path.abspath(a.repo), agent=agent)
-    print("\n".join(done))
+        agents, detected = detect_agents(home), True
+        if not agents:
+            agents = ["claude"]
+    for agent in agents:
+        if _check_agent(agent):
+            return 1
+    lines: list[str] = []
+    if detected:
+        lines.append(f"agents found here: {', '.join(agents)}  (use --agent to pick one)")
+    for agent in agents:
+        lines += install_user(home, agent=agent) if a.user else install_repo(repo, agent=agent)
+    seen: set[str] = set()
+    for ln in lines:
+        if ln not in seen:
+            seen.add(ln)
+            print(ln)
+    print("next: run `gitvow status` inside a repository to check the record is actually being written.")
+    if a.check:
+        from .selftest import run, run_agent
+
+        print()
+        worst = 0
+        for agent in agents:
+            worst = max(worst, run() if agent == "claude" else run_agent(agent))
+        if worst:
+            print("the self-check failed; `gitvow status` says what is missing", file=sys.stderr)
     return 0
 
 
 def cmd_uninstall(a: argparse.Namespace) -> int:
+    from .install import installed_agents
+
+    if not a.agent:
+        home = os.path.expanduser("~")
+        repo = os.path.abspath(a.repo)
+        found = [ag for ag, scope, _ in installed_agents(home, repo) if (scope == "user") == bool(a.user)]
+        if len(found) > 1:
+            worst = 0
+            for ag in dict.fromkeys(found):
+                worst = max(worst, cmd_uninstall(argparse.Namespace(**{**vars(a), "agent": ag})))
+            return worst
+        a.agent = found[0] if found else None
     agent = a.agent or "claude"
     if _check_agent(agent):
         return 1
@@ -464,9 +503,10 @@ def main(argv: list[str] | None = None) -> int:
     s.add_argument("--user", action="store_true")
     s.add_argument(
         "--agent",
-        default="claude",
-        help="claude|codex|gemini|cursor|copilot|factory or an external gitvow-agent-<name>",
+        help="claude|codex|gemini|cursor|copilot|factory or an external gitvow-agent-<name>; "
+        "omit to configure every agent found on this machine",
     )
+    s.add_argument("--check", action="store_true", help="run the self-check afterwards and show it working")
     s.set_defaults(f=cmd_install)
     s = sub.add_parser("uninstall", help="remove what install added")
     s.add_argument("repo", nargs="?", default=".")
@@ -477,8 +517,8 @@ def main(argv: list[str] | None = None) -> int:
     s.add_argument("--purge-snapshots", action="store_true")
     s.add_argument(
         "--agent",
-        default="claude",
-        help="claude|codex|gemini|cursor|copilot|factory or an external gitvow-agent-<name>",
+        help="claude|codex|gemini|cursor|copilot|factory or an external gitvow-agent-<name>; "
+        "omit to remove gitvow from every agent configured here",
     )
     s.set_defaults(f=cmd_uninstall)
     s = sub.add_parser("check", help="dry-run the policy: gitvow check -- git push --force")

{gitvow-0.13.0 → gitvow-0.13.2}/src/gitvow/install.py

@@ -374,18 +374,115 @@ def agent_next_steps(agent: str, home: str, repo: str | None = None) -> list[str
             "codex: its sandbox refuses writes inside .git, so the agent cannot commit at all. Add to "
             f'~/.codex/config.toml:  [sandbox_workspace_write] writable_roots = ["{gd}"]'
         )
-    out.append("check it with `gitvow status`.")
+    return out
+
+
+GIT_HOOKS_EXPECTED = ("prepare-commit-msg", "pre-push", "pre-commit", "post-commit")
+GIT_HOOK_BODIES = {
+    "prepare-commit-msg": GIT_HOOK,
+    "pre-push": PRE_PUSH_HOOK,
+    "pre-commit": PRE_COMMIT_HOOK,
+    "post-commit": POST_COMMIT_HOOK,
+}
+
+# How to tell an agent is on this machine: a configuration directory under $HOME, an absolute path, or a
+# command on the PATH. Detection only decides what install offers; it never changes what a hook does.
+AGENT_PROBES: dict[str, tuple[tuple[str, ...], tuple[str, ...], tuple[str, ...]]] = {
+    "claude": ((".claude",), (), ("claude",)),
+    "codex": ((".codex",), (), ("codex",)),
+    "gemini": ((".gemini",), (), ("gemini",)),
+    "cursor": ((".cursor",), ("/Applications/Cursor.app",), ("cursor-agent", "cursor")),
+    "copilot": ((".copilot",), (), ("copilot",)),
+    "factory": ((".factory",), (), ("droid",)),
+}
+
+
+def detect_agents(home: str) -> list[str]:
+    """Agents that look installed here, built-in first, then any external gitvow-agent-<name> found."""
+    found = [
+        agent
+        for agent, (dirs, paths, bins) in AGENT_PROBES.items()
+        if any(os.path.isdir(os.path.join(home, d)) for d in dirs)
+        or any(os.path.exists(p) for p in paths)
+        or any(shutil.which(b) for b in bins)
+    ]
+    seen = set(found)
+    for d in [os.path.join(home, ".gitvow", "agents"), *os.environ.get("PATH", "").split(os.pathsep)]:
+        try:
+            names = os.listdir(d)
+        except OSError:
+            continue
+        for n in names:
+            if n.startswith("gitvow-agent-") and os.access(os.path.join(d, n), os.X_OK):
+                name = n[len("gitvow-agent-") :]
+                if name not in seen:
+                    seen.add(name)
+                    found.append(name)
+    return found
+
+
+def hook_commands(path: str) -> list[str]:
+    """Every gitvow hook command in an agent settings file, whatever the schema around it."""
+    if not os.path.exists(path):
+        return []
+    try:
+        with open(path) as fh:
+            data = json.load(fh)
+    except (OSError, json.JSONDecodeError):
+        return []
+    out: list[str] = []
+
+    def walk(node: Any) -> None:
+        if isinstance(node, dict):
+            cmd = node.get("command")
+            if isinstance(cmd, str) and MARKER in cmd:
+                out.append(cmd)
+            for v in node.values():
+                walk(v)
+        elif isinstance(node, list):
+            for v in node:
+                walk(v)
+
+    walk(data)
+    return out
+
+
+def installed_agents(home: str, repo: str | None = None) -> list[tuple[str, str, str]]:
+    """(agent, scope, path) for every agent settings file that already carries gitvow hooks."""
+    out: list[tuple[str, str, str]] = []
+    for agent, (user_rel, repo_rel) in AGENT_FILES.items():
+        for scope, path in (("user", os.path.join(home, user_rel)), ("repo", os.path.join(repo or "", repo_rel))):
+            if scope == "repo" and not repo:
+                continue
+            if hook_commands(path):
+                out.append((agent, scope, path))
+    return out
+
+
+def expected_events(agent: str) -> set[str]:
+    """The hook events this version of gitvow installs for an agent."""
+    if agent not in AGENT_FILES:
+        return set()
+    return set(_agent_entries(agent, "gitvow"))
+
+
+def stale_git_hooks(dirpath: str) -> list[str]:
+    """Hooks whose contents are not what this version writes: an install left behind by an older gitvow."""
+    out = []
+    for name, body in GIT_HOOK_BODIES.items():
+        p = os.path.join(dirpath, name)
+        try:
+            with open(p) as fh:
+                if fh.read() != body:
+                    out.append(name)
+        except OSError:
+            continue  # missing hooks are reported separately
     return out
 
 
 def _write_git_hook(dirpath: str) -> str:
     os.makedirs(dirpath, exist_ok=True)
-    for name, body in (
-        ("prepare-commit-msg", GIT_HOOK),
-        ("pre-push", PRE_PUSH_HOOK),
-        ("pre-commit", PRE_COMMIT_HOOK),
-        ("post-commit", POST_COMMIT_HOOK),
-    ):
+    for name, body in GIT_HOOK_BODIES.items():
         p = os.path.join(dirpath, name)
         with open(p, "w") as fh:
             fh.write(body)

{gitvow-0.13.0 → gitvow-0.13.2}/src/gitvow/status.py

@@ -7,46 +7,25 @@ worst outcome, so this exists to make that state loud.
 
 from __future__ import annotations
 
-import json
 import os
 import shutil
-from typing import Any
 
-from .install import AGENT_FILES, MARKER, NOTES_GLOB, agent_next_steps
+from .install import (
+    AGENT_FILES,
+    GIT_HOOKS_EXPECTED,
+    NOTES_GLOB,
+    agent_next_steps,
+    expected_events,
+    hook_commands,
+    stale_git_hooks,
+)
 from .policy import PolicyError, load_policy
 from .redact import RedactionError, load_rules
 from .state import git, git_dir, toplevel
 
-GIT_HOOKS = ("prepare-commit-msg", "pre-commit", "post-commit", "pre-push")
 Check = tuple[str, str, str]  # (state: ok|fail|note, what, fix or detail)
 
 
-def _hook_commands(path: str) -> list[str]:
-    """Every gitvow hook command in an agent settings file, whatever the schema around it."""
-    if not os.path.exists(path):
-        return []
-    try:
-        with open(path) as fh:
-            data = json.load(fh)
-    except (OSError, json.JSONDecodeError):
-        return []
-    out: list[str] = []
-
-    def walk(node: Any) -> None:
-        if isinstance(node, dict):
-            cmd = node.get("command")
-            if isinstance(cmd, str) and MARKER in cmd:
-                out.append(cmd)
-            for v in node.values():
-                walk(v)
-        elif isinstance(node, list):
-            for v in node:
-                walk(v)
-
-    walk(data)
-    return out
-
-
 def _executable(cmd: str) -> tuple[bool, str, bool]:
     """(runnable, resolved path, found on PATH rather than recorded absolutely)."""
     parts = cmd.split()
@@ -65,7 +44,7 @@ def _agent_checks(home: str, cwd: str) -> list[Check]:
         for scope, path in (("user", os.path.join(home, user_rel)), ("repo", os.path.join(top or cwd, repo_rel))):
             if scope == "repo" and not top:
                 continue
-            cmds = _hook_commands(path)
+            cmds = hook_commands(path)
             if not cmds:
                 continue
             found_any = True
@@ -91,6 +70,15 @@ def _agent_checks(home: str, cwd: str) -> list[Check]:
                 )
             else:
                 checks.append(("ok", f"{agent} ({scope}): {len(cmds)} hooks in {where} → {resolved}", ""))
+            missing = sorted(e for e in expected_events(agent) if not any(f" {e}" in c for c in cmds))
+            if missing:
+                checks.append(
+                    (
+                        "fail",
+                        f"{agent} ({scope}): installed by an older gitvow, missing {', '.join(missing)}",
+                        f"re-run `gitvow install {'--user ' if scope == 'user' else ''}--agent {agent}`",
+                    )
+                )
             checks += _agent_notes(agent, home, top)
     if not found_any:
         checks.append(
@@ -121,7 +109,7 @@ def _git_checks(cwd: str, home: str) -> list[Check]:
         checks.append(("fail", "core.hooksPath is not set, so no commit gets a trailer", "run `gitvow install --user`"))
         return checks
     hooks_dir = hp if os.path.isabs(hp) else os.path.join(top, hp)
-    missing = [h for h in GIT_HOOKS if not os.access(os.path.join(hooks_dir, h), os.X_OK)]
+    missing = [h for h in GIT_HOOKS_EXPECTED if not os.access(os.path.join(hooks_dir, h), os.X_OK)]
     if missing:
         checks.append(
             (
@@ -131,7 +119,17 @@ def _git_checks(cwd: str, home: str) -> list[Check]:
             )
         )
     else:
-        checks.append(("ok", f"git hooks in {hp}: {', '.join(GIT_HOOKS)}", ""))
+        stale = stale_git_hooks(hooks_dir)
+        if stale:
+            checks.append(
+                (
+                    "fail",
+                    f"git hooks written by an older gitvow: {', '.join(stale)}",
+                    "re-run `gitvow install` here; behaviour added since that install is not active",
+                )
+            )
+        else:
+            checks.append(("ok", f"git hooks in {hp}: {', '.join(GIT_HOOKS_EXPECTED)}", ""))
     rc, refs, _ = git(["config", "--get-all", "notes.displayRef"], top)
     if NOTES_GLOB not in (refs or ""):
         checks.append(
@@ -179,9 +177,12 @@ def render(checks: list[Check]) -> str:
         if fix:
             lines.append("         " + fix)
     fails = sum(1 for s, _, _ in checks if s == "fail")
-    notes = sum(1 for s, _, _ in checks if s == "note")
-    lines += [
-        "",
-        f"{fails} failing, {notes} to check by hand." if fails else f"nothing failing, {notes} to check by hand.",
-    ]
+    notes = sum(1 for s, _, fix in checks if s == "note" and fix)  # only notes that ask something of you
+    tail = f" {notes} step{'s' if notes != 1 else ''} left to you above." if notes else ""
+    if fails:
+        lines += ["", f"{fails} failing: the record is not being written until those are fixed.{tail}"]
+    elif any(s == "note" and "no hook log" in w for s, w, _ in checks):
+        lines += ["", f"Ready: run a session and commit, or `gitvow selftest` to see it work now.{tail}"]
+    else:
+        lines += ["", f"The record is live here.{tail}"]
     return "\n".join(lines) + "\n"

{gitvow-0.13.0 → gitvow-0.13.2/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.13.0
+Version: 0.13.2
 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.13.0 → gitvow-0.13.2}/tests/test_adapters.py

@@ -227,7 +227,6 @@ def test_install_per_agent_idempotent_and_reversible(home, repo):
             # hooks are on by default; what install must say is that they are skipped until trusted
             assert any("/hooks" in x and "trust" in x for x in out)
             assert any("writable_roots" in x for x in out)
-            assert any("gitvow status" in x for x in out)
         if agent == "cursor":
             assert s["version"] == 1 and s["hooks"][key][0]["failClosed"] is True
         if agent == "gemini":

{gitvow-0.13.0 → gitvow-0.13.2}/tests/test_status.py

@@ -19,11 +19,11 @@ def test_a_clean_install_reports_nothing_failing(repo, home, monkeypatch):
     assert not [c for c in checks if c[0] == "fail"], checks
     assert _first(checks, "policy loads")[0] == "ok"
     assert _first(checks, "redaction rules load")[0] == "ok"
-    assert "prepare-commit-msg, pre-commit, post-commit, pre-push" in _first(checks, "git hooks in")[1]
+    assert "prepare-commit-msg, pre-push, pre-commit, post-commit" in _first(checks, "git hooks in")[1]
     # no session has run in this fixture repo yet, and status says so rather than implying it works
     assert _first(checks, "no hook log")[0] == "note"
     text = render(checks)
-    assert text.startswith("gitvow ") and "nothing failing" in text
+    assert text.startswith("gitvow ") and "Ready: run a session and commit" in text
 
 
 def test_an_unreachable_hook_command_fails_loudly(repo, home, monkeypatch):
@@ -88,6 +88,41 @@ def test_cli_status_exit_code_and_json(repo, home, monkeypatch, capsys):
 def test_install_prints_the_codex_steps(repo, home):
     out = install_user(str(home), agent="codex")
     assert any("/hooks" in x and "trust" in x for x in out)
-    assert any("gitvow status" in x for x in out)
     assert not [x for x in install_user(str(home)) if "/hooks" in x]  # claude has no extra step
     assert Path(home, ".claude", "settings.json").exists()
+
+
+def test_install_without_an_agent_configures_everything_it_finds(repo, home, monkeypatch, capsys):
+    """Forgetting --agent must not silently leave an agent ungated."""
+    from gitvow.install import detect_agents
+
+    monkeypatch.chdir(repo)
+    for d in (".codex", ".cursor"):
+        os.makedirs(home / d, exist_ok=True)
+    assert set(detect_agents(str(home))) >= {"codex", "cursor"}
+    assert cli.main(["install", str(repo)]) == 0
+    out = capsys.readouterr().out
+    assert "agents found here:" in out and "codex" in out and "cursor" in out
+    assert (repo / ".codex" / "hooks.json").exists() and (repo / ".cursor" / "hooks.json").exists()
+    assert "next: run `gitvow status`" in out
+    # and uninstall with no --agent clears every one of them, leaving any hooks of your own in place
+    from gitvow.install import hook_commands
+
+    assert cli.main(["uninstall", str(repo)]) == 0
+    for rel in (".codex/hooks.json", ".cursor/hooks.json", ".claude/settings.json"):
+        assert hook_commands(str(repo / rel)) == [], rel
+
+
+def test_an_old_install_is_reported_as_stale(repo, home, monkeypatch):
+    monkeypatch.chdir(repo)
+    install_repo(str(repo))
+    hooks = repo / ".gitvow" / "git-hooks"
+    (hooks / "pre-commit").write_text("#!/bin/sh\n# an older gitvow wrote this\nexit 0\n")
+    c = _first(build(str(repo), str(home)), "written by an older gitvow")
+    assert c and c[0] == "fail" and "pre-commit" in c[1] and "re-run" in c[2]
+    # an agent settings file from before an event existed
+    settings = json.loads((repo / ".claude" / "settings.json").read_text())
+    settings["hooks"].pop("Stop", None)
+    (repo / ".claude" / "settings.json").write_text(json.dumps(settings))
+    c = _first(build(str(repo), str(home)), "installed by an older gitvow")
+    assert c and c[0] == "fail" and "Stop" in c[1]