gitvow 0.1.0__py3-none-any.whl

gitvow/__init__.py

@@ -0,0 +1,3 @@
+"""gitvow: provenance and policy gate for AI-agent coding sessions."""
+
+__version__ = "0.1.0"

gitvow/cli.py

@@ -0,0 +1,135 @@
+"""gitvow command line."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+from . import __version__
+from .collect import collect, summarize_text
+from .hooks import HANDLERS
+from .install import install_repo, install_user, uninstall_repo, uninstall_user
+from .policy import PolicyError, evaluate, load_policy
+from .state import git
+
+
+def cmd_hook(a: argparse.Namespace) -> int:
+    try:
+        payload = json.load(sys.stdin)
+    except json.JSONDecodeError:
+        payload = {}
+    handler = HANDLERS.get(a.event)
+    if not handler:
+        print(f"unknown hook event {a.event}", file=sys.stderr)
+        return 1
+    code, msg = handler(payload)
+    if msg:
+        print(msg, file=sys.stderr)
+    return code
+
+
+def cmd_install(a: argparse.Namespace) -> int:
+    done = install_user(os.path.expanduser("~")) if a.user else install_repo(os.path.abspath(a.repo))
+    print("\n".join(done))
+    return 0
+
+
+def cmd_uninstall(a: argparse.Namespace) -> int:
+    done = (
+        uninstall_user(os.path.expanduser("~"), a.purge_policy, a.purge_ledger)
+        if a.user
+        else uninstall_repo(os.path.abspath(a.repo), a.purge_notes)
+    )
+    print("\n".join(done))
+    return 0
+
+
+def cmd_check(a: argparse.Namespace) -> int:
+    """Dry-run the policy against a command, path or MCP tool name."""
+    try:
+        pol = load_policy(os.getcwd())
+    except PolicyError as e:
+        print(f"policy error: {e}", file=sys.stderr)
+        return 2
+    if a.path:
+        d = evaluate(pol, "Edit", {"file_path": a.path})
+    elif a.mcp:
+        d = evaluate(pol, a.mcp, {})
+    else:
+        d = evaluate(pol, "Bash", {"command": " ".join(a.command)})
+    print(d.outcome.upper() + (f": {d.reason}" if d.reason else ""))
+    return 2 if d.blocks else 0
+
+
+def cmd_show(a: argparse.Namespace) -> int:
+    """Print a commit's trailers and session note."""
+    rc, msg, _ = git(["log", "-1", "--format=%H%n%s%n%b", a.commit], os.getcwd())
+    if rc != 0:
+        print(f"no such commit: {a.commit}", file=sys.stderr)
+        return 1
+    print(msg)
+    rc, note, _ = git(["notes", "--ref=sessions", "show", a.commit], os.getcwd())
+    print(note if rc == 0 else "(no session note)")
+    return 0
+
+
+def cmd_collect(a: argparse.Namespace) -> int:
+    w = collect(os.path.expanduser("~"), a.out)
+    print(summarize_text(w))
+    print(f"collected into {w}  (redacted at write time; review before sending)")
+    return 0
+
+
+def cmd_summarize(a: argparse.Namespace) -> int:
+    print(summarize_text(a.dir))
+    return 0
+
+
+def cmd_selftest(a: argparse.Namespace) -> int:
+    from .selftest import run
+
+    return run()
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(prog="gitvow", description="Provenance and policy gate for agent coding sessions.")
+    p.add_argument("--version", action="version", version=f"gitvow {__version__}")
+    sub = p.add_subparsers(dest="cmd", required=True)
+    s = sub.add_parser("hook", help="run as a Claude Code hook (reads JSON on stdin)")
+    s.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.set_defaults(f=cmd_install)
+    s = sub.add_parser("uninstall", help="remove what install added")
+    s.add_argument("repo", nargs="?", default=".")
+    s.add_argument("--user", action="store_true")
+    s.add_argument("--purge-notes", action="store_true")
+    s.add_argument("--purge-policy", action="store_true")
+    s.add_argument("--purge-ledger", action="store_true")
+    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="*")
+    s.add_argument("--path")
+    s.add_argument("--mcp")
+    s.set_defaults(f=cmd_check)
+    s = sub.add_parser("show", help="print a commit's trailers and session note")
+    s.add_argument("commit", nargs="?", default="HEAD")
+    s.set_defaults(f=cmd_show)
+    s = sub.add_parser("collect", help="gather ledger, logs, trailers and notes into one directory")
+    s.add_argument("--out", default=os.path.expanduser("~/Desktop"))
+    s.set_defaults(f=cmd_collect)
+    s = sub.add_parser("summarize", help="metrics from a collected directory")
+    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.set_defaults(f=cmd_selftest)
+    a = p.parse_args(argv)
+    return a.f(a)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

gitvow/collect.py

@@ -0,0 +1,103 @@
+"""Gather what a trial produced on this machine into one redacted directory, and compute trial metrics."""
+
+from __future__ import annotations
+
+import collections
+import glob
+import json
+import os
+import shutil
+import time
+from typing import Any
+
+from .state import git
+
+
+def collect(home: str, out_dir: str) -> str:
+    stamp = time.strftime("%Y%m%d-%H%M%S")
+    w = os.path.join(out_dir, f"gitvow-{stamp}")
+    os.makedirs(os.path.join(w, "ledger"), exist_ok=True)
+    os.makedirs(os.path.join(w, "repos"), exist_ok=True)
+    led = os.path.join(home, ".gitvow", "ledger")
+    repos: set[str] = set()
+    for f in glob.glob(os.path.join(led, "*.json")):
+        shutil.copy(f, os.path.join(w, "ledger"))
+        try:
+            with open(f) as fh:
+                r = json.load(fh).get("repo")
+            if r:
+                repos.add(r)
+        except (OSError, json.JSONDecodeError):
+            pass
+    for r in sorted(repos):
+        if not os.path.isdir(r):
+            continue
+        d = os.path.join(w, "repos", os.path.basename(r.rstrip("/")))
+        os.makedirs(d, exist_ok=True)
+        rc, gd, _ = git(["rev-parse", "--git-dir"], r)
+        if rc != 0:
+            continue
+        gd = gd if os.path.isabs(gd) else os.path.join(r, gd)
+        lp = os.path.join(gd, "gitvow-hooks.log")
+        if os.path.exists(lp):
+            shutil.copy(lp, os.path.join(d, "gitvow-hooks.log"))
+        for name, args in (
+            ("commits-with-trailers.txt", ["log", "--format=%H %ad %s", "--date=short", "--grep=Gitvow-Session:"]),
+            ("notes.txt", ["log", "--show-notes=sessions", "--format=%H%n%N%n----", "--grep=Gitvow-Session:"]),
+            ("remote.txt", ["remote", "get-url", "origin"]),
+        ):
+            _, out, _ = git(args, r)
+            with open(os.path.join(d, name), "w") as fh:
+                fh.write(out)
+    with open(os.path.join(w, "SUMMARY.txt"), "w") as fh:
+        fh.write(summarize_text(w))
+    return w
+
+
+def summarize(w: str) -> dict[str, Any]:
+    led = [json.load(open(f)) for f in glob.glob(os.path.join(w, "ledger", "*.json"))]  # noqa: SIM115
+    tools: collections.Counter[str] = collections.Counter(t.get("tool") for s in led for t in s.get("tool_calls", []))
+    kinds: collections.Counter[str] = collections.Counter()
+    reasons: collections.Counter[tuple[str, str]] = collections.Counter()
+    trailered = notes = 0
+    for lp in glob.glob(os.path.join(w, "repos", "*", "gitvow-hooks.log")):
+        with open(lp) as fh:
+            for line in fh:
+                try:
+                    e = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                kinds[e.get("kind", "?")] += 1
+                if e.get("kind") in ("blocked", "confirm_required"):
+                    reasons[(e.get("kind", "?"), e.get("reason", "?"))] += 1
+    for f in glob.glob(os.path.join(w, "repos", "*", "commits-with-trailers.txt")):
+        with open(f) as fh:
+            trailered += sum(1 for ln in fh if ln.strip())
+    for f in glob.glob(os.path.join(w, "repos", "*", "notes.txt")):
+        with open(f) as fh:
+            notes += fh.read().count("gitvow-session")
+    return {
+        "sessions": len(led),
+        "repos": len({s.get("repo") for s in led}),
+        "tool_calls": sum(tools.values()),
+        "by_tool": dict(tools.most_common(8)),
+        "commits_during_sessions": sum(len(s.get("commits_during_session", [])) for s in led),
+        "hook_decisions": dict(kinds),
+        "commits_with_trailers": trailered,
+        "notes_attached": notes,
+        "gate_fired_on": [{"kind": k, "reason": r, "n": n} for (k, r), n in reasons.most_common(20)],
+    }
+
+
+def summarize_text(w: str) -> str:
+    s = summarize(w)
+    lines = [
+        f"sessions: {s['sessions']}   repos touched: {s['repos']}",
+        f"tool calls: {s['tool_calls']} | by tool: {s['by_tool']}",
+        f"commits during sessions: {s['commits_during_sessions']}",
+        f"hook decisions: {s['hook_decisions']}",
+        f"commits with trailers: {s['commits_with_trailers']} | notes attached: {s['notes_attached']}",
+        "gate fired on:",
+    ]
+    lines += [f"  {g['kind']:<17} {g['n']:>4}  {g['reason']}" for g in s["gate_fired_on"]] or ["  (never)"]
+    return "\n".join(lines) + "\n"

gitvow/hooks/__init__.py

@@ -0,0 +1,127 @@
+"""Hook handlers. Each takes the Claude Code hook payload (dict) and returns (exit_code, stderr_message)."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import time
+from typing import Any
+
+from ..policy import PolicyError, evaluate, load_policy, message_for
+from ..redact import redact
+from ..state import git, load_state, log_event, save_state
+from ..transcript import summarize
+
+NOTES_REF = "sessions"
+COMMIT_RE = re.compile(r"\bgit\s+commit\b")
+
+
+def session_start(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    st = load_state(cwd)
+    st.update(
+        {
+            "session_id": h.get("session_id"),
+            "transcript_path": h.get("transcript_path"),
+            "started": time.strftime("%Y-%m-%dT%H:%M:%S"),
+            "steps": st.get("steps", 0),
+        }
+    )
+    save_state(cwd, st)
+    log_event(cwd, "session_start", {"session_id": h.get("session_id")})
+    return 0, ""
+
+
+def pre_tool_use(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    tool = h.get("tool_name", "") or ""
+    inp = h.get("tool_input") or {}
+    try:
+        pol = load_policy(cwd, home)
+    except PolicyError as e:
+        return (
+            2,
+            f"BLOCKED: tool policy could not be loaded ({e}); refusing all tool calls until the policy is restored.",
+        )
+    d = evaluate(pol, tool, inp)
+    if d.blocks:
+        log_event(
+            cwd,
+            "blocked" if d.outcome == "deny" else "confirm_required",
+            {"tool": tool, "reason": d.reason, "detail": redact(d.detail)[:200], "session_id": h.get("session_id")},
+        )
+        return 2, message_for(d)
+    if tool == "Bash" and COMMIT_RE.search(inp.get("command", "")):
+        st = load_state(cwd)
+        st["session_id"] = h.get("session_id") or st.get("session_id")
+        st["transcript_path"] = h.get("transcript_path") or st.get("transcript_path")
+        st["steps"] = st.get("steps", 0) + 1
+        save_state(cwd, st)
+    log_event(
+        cwd, "allowed", {"tool": tool, "detail": redact(inp.get("command") or inp.get("file_path") or tool)[:160]}
+    )
+    return 0, ""
+
+
+def post_tool_use(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    if h.get("tool_name") != "Bash" or not COMMIT_RE.search((h.get("tool_input") or {}).get("command", "")):
+        return 0, ""
+    rc, head, _ = git(["rev-parse", "HEAD"], cwd)
+    if rc != 0:
+        return 0, ""
+    st = load_state(cwd)
+    summ = summarize(h.get("transcript_path") or st.get("transcript_path"))
+    _, files, _ = git(["show", "--stat", "--format=", "HEAD"], cwd)
+    _, diffstat, _ = git(["show", "--numstat", "--format=", "HEAD"], cwd)
+    changed = [ln.split("\t")[-1] for ln in diffstat.splitlines() if ln.strip()]
+    agent_written = sorted(f for f in changed if any(f.endswith(w) or w.endswith(f) for w in summ["files_written"]))
+    note = {
+        "session_id": h.get("session_id") or st.get("session_id"),
+        "step": st.get("steps"),
+        "committed_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "assistant_turns_so_far": summ["turns"],
+        "tool_calls_so_far": len(summ["tool_calls"]),
+        "tools_used": sorted({t["tool"] for t in summ["tool_calls"] if t.get("tool")}),
+        "last_stated_plan": summ["last_assistant_text"],
+        "files_in_commit": [ln.strip() for ln in files.splitlines()[:-1]][:50] if files else [],
+        "files_written_by_agent_this_session": agent_written[:50],
+        "attribution": {"files_in_commit": len(changed), "touched_by_agent": len(agent_written)},
+        "transcript": "kept local; see ledger",
+        "redaction": "secrets/PII patterns and high-entropy tokens replaced at write time",
+    }
+    body = "gitvow-session\n" + json.dumps(note, indent=1)
+    git(["notes", f"--ref={NOTES_REF}", "add", "-f", "-m", body, head], cwd)
+    log_event(cwd, "note_added", {"commit": head[:12], "session_id": note["session_id"], "step": note["step"]})
+    return 0, f"session note attached to {head[:12]} (refs/notes/{NOTES_REF})"
+
+
+def stop(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
+    cwd = h.get("cwd") or os.getcwd()
+    home = home or os.path.expanduser("~")
+    st = load_state(cwd)
+    summ = summarize(h.get("transcript_path") or st.get("transcript_path"))
+    led = os.path.join(home, ".gitvow", "ledger")
+    os.makedirs(led, exist_ok=True)
+    commits: list[str] = []
+    if st.get("started"):
+        rc, out, _ = git(["log", "--format=%H", f"--since={st['started']}"], cwd)
+        commits = out.split() if rc == 0 else []
+    rec = {
+        "session_id": h.get("session_id"),
+        "repo": cwd,
+        "started": st.get("started"),
+        "ended": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        "assistant_turns": summ["turns"],
+        "tool_calls": summ["tool_calls"],
+        "commits_during_session": commits,
+        "last_stated_plan": summ["last_assistant_text"],
+    }
+    with open(os.path.join(led, f"{h.get('session_id') or 'unknown'}.json"), "w") as fh:
+        json.dump(rec, fh, indent=1)
+    log_event(cwd, "session_stop", {"session_id": h.get("session_id"), "tool_calls": len(summ["tool_calls"])})
+    return 0, ""
+
+
+HANDLERS = {"SessionStart": session_start, "PreToolUse": pre_tool_use, "PostToolUse": post_tool_use, "Stop": stop}

gitvow/install.py

@@ -0,0 +1,158 @@
+"""Install/uninstall into Claude Code settings and git hooks, per user or per repo. Idempotent; removes only what it added."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+from typing import Any
+
+from .state import git
+
+GIT_HOOK = """#!/bin/sh
+# gitvow: append session trailers when a session is active in this repo; chain to the repo's own hook if present.
+GD="$(git rev-parse --git-dir)"; STATE="$GD/gitvow-session.json"
+if [ -f "$STATE" ]; then
+  SID=$(python3 -c "import json;print(json.load(open('$STATE')).get('session_id') or '')" 2>/dev/null)
+  STEP=$(python3 -c "import json;print(json.load(open('$STATE')).get('steps') or 0)" 2>/dev/null)
+  if [ -n "$SID" ] && ! grep -q "^Gitvow-Session:" "$1"; then printf "\\nGitvow-Session: %s\\nGitvow-Step: %s\\n" "$SID" "$STEP" >> "$1"; fi
+fi
+SELF="$(cd "$(dirname "$0")" && pwd)"; REPOHOOKS="$(cd "$GD/hooks" 2>/dev/null && pwd || true)"
+[ -x "$GD/hooks/prepare-commit-msg" ] && [ "$SELF" != "$REPOHOOKS" ] && exec "$GD/hooks/prepare-commit-msg" "$@"
+exit 0
+"""
+MARKER = "gitvow hook "
+
+
+def _hook_entries(cmd_prefix: str) -> dict[str, list[dict[str, Any]]]:
+    def entry(event: str, matcher: str | None) -> dict[str, Any]:
+        e: dict[str, Any] = {"hooks": [{"type": "command", "command": f"{cmd_prefix} hook {event}"}]}
+        if matcher:
+            e["matcher"] = matcher
+        return e
+
+    return {
+        "SessionStart": [entry("SessionStart", None)],
+        "PreToolUse": [entry("PreToolUse", "Bash|Edit|Write|MultiEdit|NotebookEdit|mcp__.*")],
+        "PostToolUse": [entry("PostToolUse", "Bash")],
+        "Stop": [entry("Stop", None)],
+    }
+
+
+def merge_settings(path: str, cmd_prefix: str) -> None:
+    cur: dict[str, Any] = {}
+    if os.path.exists(path):
+        with open(path) as fh:
+            cur = json.load(fh)
+    hooks = cur.setdefault("hooks", {})
+    for ev, entries in _hook_entries(cmd_prefix).items():
+        kept = [x for x in hooks.get(ev, []) if not any(MARKER in (h.get("command") or "") for h in x.get("hooks", []))]
+        hooks[ev] = kept + entries
+    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
+    with open(path, "w") as fh:
+        json.dump(cur, fh, indent=2)
+
+
+def unmerge_settings(path: str) -> None:
+    if not os.path.exists(path):
+        return
+    with open(path) as fh:
+        cur = json.load(fh)
+    hooks = cur.get("hooks", {})
+    for ev in list(hooks):
+        hooks[ev] = [x for x in hooks[ev] if not any(MARKER in (h.get("command") or "") for h in x.get("hooks", []))]
+        if not hooks[ev]:
+            del hooks[ev]
+    if not hooks:
+        cur.pop("hooks", None)
+    if cur:
+        with open(path, "w") as fh:
+            json.dump(cur, fh, indent=2)
+    else:
+        os.remove(path)
+
+
+def _write_git_hook(dirpath: str) -> str:
+    os.makedirs(dirpath, exist_ok=True)
+    p = os.path.join(dirpath, "prepare-commit-msg")
+    with open(p, "w") as fh:
+        fh.write(GIT_HOOK)
+    os.chmod(p, 0o755)  # noqa: S103  # nosec B103 - git runs hooks as the invoking user; must be executable
+    return p
+
+
+def install_user(home: str, cmd_prefix: str = "gitvow") -> list[str]:
+    base = os.path.join(home, ".gitvow")
+    os.makedirs(base, exist_ok=True)
+    done = []
+    pol = os.path.join(base, "policy.json")
+    if not os.path.exists(pol):
+        from .policy import DEFAULT_POLICY_PATH
+
+        shutil.copy(DEFAULT_POLICY_PATH, pol)
+        done.append(f"default policy → {pol}")
+    _write_git_hook(os.path.join(base, "git-hooks"))
+    merge_settings(os.path.join(home, ".claude", "settings.json"), cmd_prefix)
+    git(["config", "--global", "core.hooksPath", os.path.join(base, "git-hooks")], home)
+    done += ["hooks merged into ~/.claude/settings.json", "global core.hooksPath → ~/.gitvow/git-hooks"]
+    return done
+
+
+def uninstall_user(home: str, purge_policy: bool = False, purge_ledger: bool = False) -> list[str]:
+    base = os.path.join(home, ".gitvow")
+    done = []
+    unmerge_settings(os.path.join(home, ".claude", "settings.json"))
+    rc, cur, _ = git(["config", "--global", "--get", "core.hooksPath"], home)
+    if rc == 0 and cur == os.path.join(base, "git-hooks"):
+        git(["config", "--global", "--unset", "core.hooksPath"], home)
+        done.append("global core.hooksPath unset")
+    shutil.rmtree(os.path.join(base, "git-hooks"), ignore_errors=True)
+    if purge_policy and os.path.exists(os.path.join(base, "policy.json")):
+        os.remove(os.path.join(base, "policy.json"))
+        done.append("policy removed")
+    if purge_ledger:
+        shutil.rmtree(os.path.join(base, "ledger"), ignore_errors=True)
+        done.append("ledger removed")
+    done.append("hook entries removed from ~/.claude/settings.json")
+    return done
+
+
+def install_repo(repo: str, cmd_prefix: str = "gitvow") -> list[str]:
+    base = os.path.join(repo, ".gitvow")
+    os.makedirs(base, exist_ok=True)
+    from .policy import DEFAULT_POLICY_PATH
+
+    pol = os.path.join(base, "policy.json")
+    if not os.path.exists(pol):
+        shutil.copy(DEFAULT_POLICY_PATH, pol)
+    _write_git_hook(os.path.join(base, "git-hooks"))
+    merge_settings(os.path.join(repo, ".claude", "settings.json"), cmd_prefix)
+    git(["config", "core.hooksPath", ".gitvow/git-hooks"], repo)
+    return [
+        f"policy → {pol}",
+        "hooks merged into .claude/settings.json",
+        "core.hooksPath → .gitvow/git-hooks",
+        "commit .gitvow/ and .claude/settings.json to share; teammates run: git config core.hooksPath .gitvow/git-hooks",
+    ]
+
+
+def uninstall_repo(repo: str, purge_notes: bool = False) -> list[str]:
+    done = []
+    unmerge_settings(os.path.join(repo, ".claude", "settings.json"))
+    rc, cur, _ = git(["config", "--get", "core.hooksPath"], repo)
+    if rc == 0 and cur == ".gitvow/git-hooks":
+        git(["config", "--unset", "core.hooksPath"], repo)
+        done.append("core.hooksPath unset")
+    shutil.rmtree(os.path.join(repo, ".gitvow"), ignore_errors=True)
+    rc, gd, _ = git(["rev-parse", "--git-dir"], repo)
+    if rc == 0:
+        gd = gd if os.path.isabs(gd) else os.path.join(repo, gd)
+        for f in ("gitvow-session.json", "gitvow-hooks.log"):
+            p = os.path.join(gd, f)
+            if os.path.exists(p):
+                os.remove(p)
+    if purge_notes:
+        git(["update-ref", "-d", "refs/notes/sessions"], repo)
+        done.append("local refs/notes/sessions deleted (remote copies untouched)")
+    done.append(".gitvow removed; commit trailers already in history remain")
+    return done

gitvow/policy.py

@@ -0,0 +1,120 @@
+"""Tool-call policy: deny → confirm → allow, evaluated on Bash command text, edited file paths, and MCP tool names."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import subprocess
+from dataclasses import dataclass
+from typing import Any
+
+DEFAULT_POLICY_PATH = os.path.join(os.path.dirname(__file__), "default_policy.json")
+
+
+class PolicyError(Exception):
+    """Raised when no valid policy can be loaded. Callers must fail closed."""
+
+
+@dataclass(frozen=True)
+class Decision:
+    outcome: str  # "allow" | "deny" | "confirm"
+    reason: str = ""
+    detail: str = ""
+
+    @property
+    def blocks(self) -> bool:
+        return self.outcome != "allow"
+
+
+def load_policy(cwd: str | None = None, home: str | None = None) -> dict[str, Any]:
+    """Precedence: <repo>/.gitvow/policy.json → ~/.gitvow/policy.json → package default."""
+    cwd = cwd or os.getcwd()
+    home = home or os.path.expanduser("~")
+    for p in (
+        os.path.join(cwd, ".gitvow", "policy.json"),
+        os.path.join(home, ".gitvow", "policy.json"),
+        DEFAULT_POLICY_PATH,
+    ):
+        if os.path.exists(p):
+            try:
+                with open(p) as fh:
+                    pol = json.load(fh)
+            except (OSError, json.JSONDecodeError) as e:
+                raise PolicyError(f"{p}: {e}") from e
+            _validate(pol, p)
+            return pol
+    raise PolicyError("no policy.json found")
+
+
+def _validate(pol: dict[str, Any], path: str) -> None:
+    for key in ("bash_deny", "bash_confirm", "path_confirm"):
+        for rule in pol.get(key, []):
+            if not isinstance(rule, dict) or "pattern" not in rule:
+                raise PolicyError(f"{path}: {key} entries need a 'pattern'")
+            try:
+                re.compile(rule["pattern"])
+            except re.error as e:
+                raise PolicyError(f"{path}: bad regex in {key}: {rule['pattern']} ({e})") from e
+    for key in ("mcp_allow", "mcp_deny"):
+        for pat in pol.get(key, []):
+            try:
+                re.compile(pat)
+            except re.error as e:
+                raise PolicyError(f"{path}: bad regex in {key}: {pat} ({e})") from e
+
+
+def evaluate(pol: dict[str, Any], tool: str, tool_input: dict[str, Any]) -> Decision:
+    text = tool_input.get("command", "") if tool == "Bash" else ""
+    path = tool_input.get("file_path", "") or tool_input.get("notebook_path", "")
+    if tool == "Bash":
+        for r in pol.get("bash_deny", []):
+            if re.search(r["pattern"], text):
+                return Decision("deny", r.get("reason", "denied"), text)
+        for r in pol.get("bash_confirm", []):
+            if re.search(r["pattern"], text):
+                return Decision("confirm", r.get("reason", "needs confirmation"), text)
+    if tool in ("Edit", "Write", "MultiEdit", "NotebookEdit") and path:
+        for r in pol.get("path_confirm", []):
+            if re.search(r["pattern"], path):
+                return Decision("confirm", r.get("reason", "sensitive path"), path)
+    if tool.startswith("mcp__"):
+        if any(re.fullmatch(p, tool) for p in pol.get("mcp_deny", [])):
+            return Decision("deny", "MCP tool on deny list", tool)
+        allow = pol.get("mcp_allow", [])
+        if allow and not any(re.fullmatch(p, tool) for p in allow):
+            return Decision("confirm", "MCP tool not on allow list", tool)
+    clf = pol.get("llm_classifier") or {}
+    if clf.get("enabled") and clf.get("command"):
+        return _classify(clf["command"], tool, tool_input, text or path or tool)
+    return Decision("allow")
+
+
+def _classify(command: str, tool: str, tool_input: dict[str, Any], detail: str) -> Decision:
+    payload = json.dumps({"tool_name": tool, "tool_input": tool_input})
+    try:
+        argv = shlex.split(command) if isinstance(command, str) else [str(a) for a in command]
+        if not argv:
+            return Decision("confirm", "classifier command is empty", detail)
+        # No shell: the policy file names a program and its arguments, so policy text
+        # can never become shell syntax.
+        r = subprocess.run(argv, input=payload, capture_output=True, text=True, timeout=30, check=False)
+    except (OSError, subprocess.TimeoutExpired):
+        return Decision("confirm", "classifier unavailable", detail)
+    parts = r.stdout.strip().split(maxsplit=1) or ["ALLOW"]
+    verdict, reason = parts[0].upper(), (parts[1] if len(parts) > 1 else "")
+    if verdict == "DENY":
+        return Decision("deny", "classifier: " + reason, detail)
+    if verdict == "CONFIRM":
+        return Decision("confirm", "classifier: " + reason, detail)
+    return Decision("allow")
+
+
+def message_for(d: Decision) -> str:
+    if d.outcome == "deny":
+        return f"BLOCKED by policy ({d.reason})."
+    return (
+        f"CONFIRMATION REQUIRED ({d.reason}). Ask the user explicitly before doing this; "
+        "if they confirm, tell them to re-run with the policy exception or perform it manually."
+    )

gitvow/redact.py

@@ -0,0 +1,71 @@
+"""Redaction of secrets and personal data at write time. Best effort by design; see SECURITY.md."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from collections import Counter
+from collections.abc import Callable, Iterable
+
+_EMAIL = re.compile(r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}")
+
+
+def _email_token(m: re.Match[str]) -> str:
+    return "[email:" + hashlib.sha256(m.group(0).lower().encode()).hexdigest()[:8] + "]"
+
+
+PATTERNS: list[tuple[re.Pattern[str], str | Callable[[re.Match[str]], str]]] = [
+    (re.compile(r"AKIA[0-9A-Z]{16}"), "[aws-access-key]"),
+    (re.compile(r"(?i)(aws_secret_access_key|secret_access_key)\s*[:=]\s*\S+"), r"\1=[redacted]"),
+    (re.compile(r"eyJ[A-Za-z0-9_-]{10,}\.eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}"), "[jwt]"),
+    (re.compile(r"\b(gh[pousr]|github_pat)_[A-Za-z0-9_]{20,}"), "[github-token]"),
+    (re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "[api-key]"),
+    (re.compile(r"\bxox[abprs]-[A-Za-z0-9-]{10,}"), "[slack-token]"),
+    (re.compile(r"\bAIza[0-9A-Za-z_-]{35}"), "[google-api-key]"),
+    (
+        re.compile(
+            r"(?i)(password|passwd|pwd|token|secret|api[_-]?key|authorization|bearer)\s*[:=]\s*[\"']?[^\s\"']{6,}"
+        ),
+        r"\1=[redacted]",
+    ),
+    (re.compile(r"(?i)\b(mysql|postgres(?:ql)?|redis|mongodb(?:\+srv)?|amqp)://[^\s\"']+"), r"\1://[redacted-dsn]"),
+    (re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----"), "[private-key]"),
+    (_EMAIL, _email_token),
+    (re.compile(r"\b\d{3}-\d{2}-\d{4}\b"), "[ssn-like]"),
+    (re.compile(r"\b\d(?:[ -]?\d){12,18}\b(?![ -]?\d)"), "[card-like-number]"),
+    (re.compile(r"\b(?:\d{1,3}\.){3}\d{1,3}\b"), "[ip]"),
+]
+
+_ENTROPY_TOKEN = re.compile(r"[A-Za-z0-9+/=_-]{20,}")
+
+
+def shannon_entropy(s: str) -> float:
+    if not s:
+        return 0.0
+    counts = Counter(s)
+    n = len(s)
+    return -sum((c / n) * math.log2(c / n) for c in counts.values())
+
+
+def redact_high_entropy(s: str, threshold: float = 4.5, min_len: int = 20) -> str:
+    """Replace long alphanumeric runs whose Shannon entropy exceeds the threshold. Catches unknown secret formats."""
+
+    def repl(m: re.Match[str]) -> str:
+        tok = m.group(0)
+        if len(tok) >= min_len and shannon_entropy(tok) > threshold and not tok.startswith(("http", "/")):
+            return "[high-entropy]"
+        return tok
+
+    return _ENTROPY_TOKEN.sub(repl, s)
+
+
+def redact(value: object, custom: Iterable[tuple[str, str]] = ()) -> str:
+    """Redact a string (or JSON-serialisable value). Custom rules are (regex, replacement) pairs applied first."""
+    s = value if isinstance(value, str) else json.dumps(value, default=str)
+    for pat, custom_rep in custom:
+        s = re.sub(pat, custom_rep, s)
+    for rx, rep in PATTERNS:
+        s = rx.sub(rep, s)
+    return redact_high_entropy(s)

gitvow/selftest.py

@@ -0,0 +1,95 @@
+"""Self-check: drives every hook in a throwaway repository and reports pass/fail. Never touches a real repository."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tempfile
+
+from .hooks import post_tool_use, pre_tool_use, session_start, stop
+from .install import _write_git_hook
+
+
+def run() -> int:
+    home = tempfile.mkdtemp(prefix="gitvow-home-")
+    repo = tempfile.mkdtemp(prefix="gitvow-repo-")
+    results: list[tuple[bool, str]] = []
+
+    def g(*a: str) -> str:
+        return subprocess.run(["git", *a], cwd=repo, capture_output=True, text=True).stdout.strip()
+
+    try:
+        g("init", "-q")
+        g("config", "user.email", "selftest@local")
+        g("config", "user.name", "selftest")
+        with open(os.path.join(repo, "a.txt"), "w") as fh:
+            fh.write("a\n")
+        g("add", "a.txt")
+        g("commit", "-qm", "init")
+        base = {"session_id": "selftest-session", "transcript_path": "", "cwd": repo}
+        session_start(base, home)
+        results.append((os.path.exists(os.path.join(repo, ".git", "gitvow-session.json")), "session recorded in .git"))
+        results.append(
+            (
+                pre_tool_use(
+                    {**base, "tool_name": "Bash", "tool_input": {"command": "git push --force origin main"}}, home
+                )[0]
+                == 2,
+                "deny: force push blocked",
+            )
+        )
+        results.append(
+            (
+                pre_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "git push origin feat"}}, home)[0]
+                == 2,
+                "confirm: git push requires asking",
+            )
+        )
+        results.append(
+            (
+                pre_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "ls -la"}}, home)[0] == 0,
+                "allow: harmless command",
+            )
+        )
+        results.append(
+            (
+                pre_tool_use({**base, "tool_name": "Edit", "tool_input": {"file_path": "x/authz_rules.py"}}, home)[0]
+                == 2,
+                "confirm: gate-bearing file edit",
+            )
+        )
+        results.append(
+            (
+                pre_tool_use({**base, "tool_name": "mcp__x__delete_thing", "tool_input": {}}, home)[0] == 2,
+                "deny: destructive MCP tool",
+            )
+        )
+        pre_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, home)
+        hooks_dir = os.path.join(repo, ".gitvow", "git-hooks")
+        _write_git_hook(hooks_dir)
+        g("config", "core.hooksPath", ".gitvow/git-hooks")
+        with open(os.path.join(repo, "a.txt"), "a") as fh:
+            fh.write("b\n")
+        g("commit", "-qam", "selftest commit")
+        results.append(("Gitvow-Session:" in g("log", "-1", "--format=%B"), "commit trailer added"))
+        post_tool_use({**base, "tool_name": "Bash", "tool_input": {"command": "git commit -m x"}}, home)
+        results.append(
+            (
+                g("notes", "--ref=sessions", "list").count("\n") + (1 if g("notes", "--ref=sessions", "list") else 0)
+                == 1,
+                "session note attached",
+            )
+        )
+        stop(base, home)
+        results.append(
+            (os.path.exists(os.path.join(home, ".gitvow", "ledger", "selftest-session.json")), "ledger written")
+        )
+    finally:
+        shutil.rmtree(home, ignore_errors=True)
+        shutil.rmtree(repo, ignore_errors=True)
+    for ok, name in results:
+        print(("  ok   " if ok else "  FAIL ") + name)
+    failed = sum(1 for ok, _ in results if not ok)
+    print(f"\nselftest: {len(results) - failed} passed, {failed} failed")
+    return 1 if failed else 0

gitvow/state.py

@@ -0,0 +1,52 @@
+"""Per-repository state kept inside .git (never in the tree) and the append-only hook log."""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import time
+from typing import Any
+
+
+def git(args: list[str], cwd: str) -> tuple[int, str, str]:
+    r = subprocess.run(["git", *args], cwd=cwd, capture_output=True, text=True)
+    return r.returncode, r.stdout.strip(), r.stderr.strip()
+
+
+def git_dir(cwd: str) -> str | None:
+    rc, out, _ = git(["rev-parse", "--git-dir"], cwd)
+    if rc != 0:
+        return None
+    return out if os.path.isabs(out) else os.path.join(cwd, out)
+
+
+def state_path(cwd: str) -> str | None:
+    gd = git_dir(cwd)
+    return os.path.join(gd, "gitvow-session.json") if gd else None
+
+
+def load_state(cwd: str) -> dict[str, Any]:
+    p = state_path(cwd)
+    if p and os.path.exists(p):
+        try:
+            with open(p) as fh:
+                return json.load(fh)
+        except (OSError, json.JSONDecodeError):
+            return {}
+    return {}
+
+
+def save_state(cwd: str, st: dict[str, Any]) -> None:
+    p = state_path(cwd)
+    if p:
+        with open(p, "w") as fh:
+            json.dump(st, fh, indent=1)
+
+
+def log_event(cwd: str, kind: str, payload: dict[str, Any]) -> None:
+    gd = git_dir(cwd)
+    if not gd:
+        return
+    with open(os.path.join(gd, "gitvow-hooks.log"), "a") as fh:
+        fh.write(json.dumps({"ts": time.strftime("%Y-%m-%dT%H:%M:%S"), "kind": kind, **payload}) + "\n")

gitvow/transcript.py

@@ -0,0 +1,47 @@
+"""Structural, redacted summary of an agent transcript (Claude Code JSONL). Tool output is never read."""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any
+
+from .redact import redact
+
+
+def summarize(path: str | None, max_tools: int = 500) -> 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()
+    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)[: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))[: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"])[:600]
+    out["files_written"] = sorted(written)
+    return out

gitvow-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: gitvow
+Version: 0.1.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
+Project-URL: Homepage, https://wirevow.dev/gitvow
+Project-URL: Documentation, https://wirevow.dev/gitvow
+Project-URL: Repository, https://github.com/wirevow/gitvow
+Project-URL: Security, https://github.com/wirevow/gitvow/blob/main/SECURITY.md
+Keywords: git,provenance,ai-agents,claude-code,hooks,policy
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: bandit>=1.7; extra == "dev"
+Requires-Dist: pip-audit>=2.7; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Dynamic: license-file
+
+# gitvow
+
+Provenance and a policy gate for AI-agent coding sessions, stored in the git you already have.
+
+[![ci](https://github.com/wirevow/gitvow/actions/workflows/ci.yml/badge.svg)](https://github.com/wirevow/gitvow/actions/workflows/ci.yml)
+[![codeql](https://github.com/wirevow/gitvow/actions/workflows/codeql.yml/badge.svg)](https://github.com/wirevow/gitvow/actions/workflows/codeql.yml)
+![python](https://img.shields.io/badge/python-3.9%E2%80%933.12-blue) ![deps](https://img.shields.io/badge/runtime%20deps-0-brightgreen) ![license](https://img.shields.io/badge/license-Apache--2.0-blue)
+
+**Who made this change, what were they trying to do, and was it allowed?** For code written with AI agents, git alone cannot answer. gitvow makes it answer.
+
+- Commits made during an agent session carry the session id and a step number as **trailers**.
+- Each such commit gets a **session note**: the agent's stated plan, the tools it used, the files it touched, how much of the commit it wrote. Redacted, stored as a git note, never in the tree.
+- Every tool call passes a **gate** first: destructive commands are refused, risky ones require asking you, edits to gate-bearing files need a human. The rules are a JSON file you own. Missing policy fails closed.
+- A **ledger** of the whole session stays in your home directory. Nothing leaves the machine unless you push it.
+
+Standard-library Python and git. No runtime dependencies, no network calls, no telemetry.
+
+## Quick start
+
+```sh
+pip install gitvow
+gitvow install --user
+gitvow selftest
+```
+
+Work in Claude Code as usual. When the agent commits:
+
+```sh
+$ git log -1 --format=%B
+Fix week-start cache key
+
+Gitvow-Session: 8f3d5c71-574a-4eec-8903-9425e3a8335b
+Gitvow-Step: 4
+
+$ gitvow show HEAD
+...
+gitvow-session
+{
+ "step": 4,
+ "tools_used": ["Bash", "Edit", "Read"],
+ "last_stated_plan": "Change the cache key to include week start so per-org settings do not collide...",
+ "files_in_commit": ["query-engine/.../QueryCacheHelper.java | 4 +++-"],
+ "files_written_by_agent_this_session": ["query-engine/.../QueryCacheHelper.java"],
+ "attribution": {"files_in_commit": 1, "touched_by_agent": 1}
+}
+```
+
+Try the gate by hand:
+
+```sh
+gitvow check -- git push --force          # DENY: force push
+gitvow check -- kubectl apply -f x.yaml   # CONFIRM: cluster apply
+gitvow check --path core/authz_rules.go   # CONFIRM: edits an authorization or gate file
+```
+
+Remove everything:
+
+```sh
+gitvow uninstall --user
+```
+
+## Documentation
+
+The docs site is the source of truth: **https://wirevow.dev/gitvow** (built from `docs/`).
+
+- [Quick start](docs/quickstart.md)
+- Concepts: [Sessions, steps and notes](docs/concepts/sessions.md) · [The gate](docs/concepts/gate.md) · [What stays out of git](docs/concepts/storage.md)
+- Guides: [Install per user or per repo](docs/guides/install.md) · [Write a policy](docs/guides/policy.md) · [Read a commit's session](docs/guides/reading.md) · [Run a trial](docs/guides/trial.md) · [Redaction](docs/guides/redaction.md)
+- Reference: [CLI](docs/reference/cli.md) · [Hook payloads](docs/reference/hooks.md) · [Note schema](docs/reference/note.md) · [Policy schema](docs/reference/policy.md)
+- [Security](docs/security.md) · [Roadmap](docs/roadmap.md) · [FAQ](docs/faq.md)
+
+## How it works
+
+```
+Claude Code ──hook──▶ gitvow hook PreToolUse ──▶ policy ──▶ allow / confirm / deny  (exit 0 / 2 / 2)
+            ──hook──▶ gitvow hook PostToolUse ─▶ on `git commit`: read transcript → redact → git notes add
+git commit ──prepare-commit-msg──▶ Gitvow-Session / Gitvow-Step trailers   (from .git/gitvow-session.json)
+Claude Code ──hook──▶ gitvow hook Stop ─────────▶ ~/.gitvow/ledger/<session>.json
+```
+
+| Data | Where | Enters git? |
+|---|---|---|
+| session id, step | commit trailers | yes |
+| session note (structure, redacted plan, attribution) | `refs/notes/sessions` | as a note; local until pushed |
+| ledger, hook log, session state | `~/.gitvow/`, `<repo>/.git/` | no |
+| transcript | untouched | never |
+
+## Status
+
+0.1.0. Used in a small internal trial; the [roadmap](docs/roadmap.md) lists what comes next and what is deliberately not planned. Claude Code is the only agent supported today; the hook payload is [documented](docs/reference/hooks.md) so adapters are straightforward.
+
+## Contributing and security
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) and [SECURITY.md](SECURITY.md). Reproductions of redaction gaps must use synthetic secrets.
+
+Apache-2.0.

gitvow-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+gitvow/__init__.py,sha256=2ucnFWzCsC7eNPXs7KSaA5NNOZzE7XCtuLOtxrGPYRw,94
+gitvow/cli.py,sha256=YdsHTZ4RTIo6SseT3-guciqxIKbKyAknoy_PefchqPI,4656
+gitvow/collect.py,sha256=5cyLpRDYvuC1mHOjgCDUlR4_22jyj-RS2U8u14JW4f8,4279
+gitvow/install.py,sha256=kbfxAg3jmD_xuX9bBXBwwgg2qUWgPG-Sdf0CphtGbt4,6513
+gitvow/policy.py,sha256=KEawRpYGPZYw-sEO20Qc-AzVUbpFu_Wx5B1QAe7I0IU,4986
+gitvow/redact.py,sha256=K3KgpqXuhi5oRSDasVy_-qzJ0moqoBEZacMroc4400U,2864
+gitvow/selftest.py,sha256=8JJ06e5JId34iLWyiAub0jlU3c7MGjBwjj8oL-izsDU,3731
+gitvow/state.py,sha256=cyxI47N4WsMYiDl5hGLiny2QAbgGsEbSRzgOrvzDF2k,1456
+gitvow/transcript.py,sha256=f6RpBlokbm9wBjFfSwfdVHA3M1wBvFYGwAnHdDOQjIA,1993
+gitvow/hooks/__init__.py,sha256=cs8E4VuA2mVEBVoAXz3j3dSof0RAz8sXhcr2Q1NASEQ,5399
+gitvow-0.1.0.dist-info/licenses/LICENSE,sha256=w3ZN927TGUiCY6tMBF4jHIthy-WAF27Tnwmr6e1eTkE,748
+gitvow-0.1.0.dist-info/METADATA,sha256=vhnPaOWfZqsdecRag5vxhphbq2vTTbo75mg-9YgERuk,5788
+gitvow-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+gitvow-0.1.0.dist-info/entry_points.txt,sha256=sU94uRlBBoLDyNMOAiT912qlUEWbIq0Gj0IczuVPLJY,43
+gitvow-0.1.0.dist-info/top_level.txt,sha256=MnguFlgJkvcXr6GvxMJeKddQbW581wRuh5NC6tDeqEw,7
+gitvow-0.1.0.dist-info/RECORD,,

gitvow-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gitvow-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+gitvow = gitvow.cli:main

gitvow-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2026 gitvow contributors
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

gitvow-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gitvow