gitvow 0.3.0__tar.gz → 0.4.0__tar.gz

{gitvow-0.3.0/src/gitvow.egg-info → gitvow-0.4.0}/PKG-INFO

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

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

@@ -13,6 +13,7 @@ from .collect import collect, summarize_text
 from .hooks import HANDLERS, LEGACY_NOTES_REF, notes_ref
 from .install import install_repo, install_user, uninstall_repo, uninstall_user
 from .policy import PolicyError, evaluate, load_policy
+from .providers import QUESTIONS, ask
 from .redact import RedactionError, load_rules, redact
 from .report import build, render_markdown
 from .state import git
@@ -66,6 +67,26 @@ def cmd_check(a: argparse.Namespace) -> int:
     return 2 if d.blocks else 0
 
 
+def cmd_ask(a: argparse.Namespace) -> int:
+    """Ask every configured provider one question and show the gate's decision."""
+    try:
+        pol = load_policy(os.getcwd())
+    except PolicyError as e:
+        print(f"policy error: {e}", file=sys.stderr)
+        return 2
+    if not pol.get("providers"):
+        print("no providers configured in the active policy", file=sys.stderr)
+        return 1
+    path = a.path or (a.subject if a.question == "gate_bearing" else "")
+    answers = ask(pol, "Edit", {"file_path": path}, os.getcwd(), only=[(a.question, a.subject)])
+    for ans in answers:
+        ev = " — " + "; ".join(ans.evidence) if ans.evidence else ""
+        print(f"{ans.provider}: {ans.answer}{ev}")
+    blocked = any(x.blocks for x in answers)
+    print("decision: " + ("CONFIRM" if blocked else "ALLOW"))
+    return 2 if blocked 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())
@@ -164,6 +185,11 @@ def main(argv: list[str] | None = None) -> int:
     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("ask", help="ask configured providers a question: gitvow ask route_gate /v1/x --path src/api.py")
+    s.add_argument("question", choices=QUESTIONS)
+    s.add_argument("subject")
+    s.add_argument("--path", default="")
+    s.set_defaults(f=cmd_ask)
     s = sub.add_parser("redact", help="apply built-in redaction plus your rules files to text")
     s.add_argument("text", nargs="+")
     s.set_defaults(f=cmd_redact)

{gitvow-0.3.0 → gitvow-0.4.0}/src/gitvow/hooks/__init__.py

@@ -64,7 +64,7 @@ def pre_tool_use(h: dict[str, Any], home: str | None = None) -> tuple[int, str]:
             2,
             f"BLOCKED: tool policy could not be loaded ({e}); refusing all tool calls until the policy is restored.",
         )
-    d = evaluate(pol, tool, inp)
+    d = evaluate(pol, tool, inp, cwd)
     rules, warn = _rules_or_none(cwd, home)
     if d.blocks:
         payload: dict[str, Any] = {"tool": tool, "reason": d.reason, "session_id": h.get("session_id")}

{gitvow-0.3.0 → gitvow-0.4.0}/src/gitvow/policy.py

@@ -10,6 +10,8 @@ import subprocess
 from dataclasses import dataclass
 from typing import Any
 
+from . import providers as _providers
+
 DEFAULT_POLICY_PATH = os.path.join(os.path.dirname(__file__), "default_policy.json")
 
 
@@ -63,9 +65,18 @@ def _validate(pol: dict[str, Any], path: str) -> None:
                 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:
+    provs = pol.get("providers", [])
+    if not isinstance(provs, list):
+        raise PolicyError(f"{path}: providers must be a list")
+    for prov in provs:
+        if not isinstance(prov, dict) or not prov.get("name") or not prov.get("command"):
+            raise PolicyError(f"{path}: each provider needs 'name' and 'command'")
+        bad = [q for q in prov.get("questions", []) if q not in _providers.QUESTIONS]
+        if bad:
+            raise PolicyError(f"{path}: provider {prov['name']} lists unknown questions {bad}")
+
+
+def evaluate(pol: dict[str, Any], tool: str, tool_input: dict[str, Any], cwd: str | None = None) -> 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":
@@ -85,6 +96,10 @@ def evaluate(pol: dict[str, Any], tool: str, tool_input: dict[str, Any]) -> Deci
         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)
+    if pol.get("providers") and tool in ("Edit", "Write", "MultiEdit", "NotebookEdit"):
+        hits = [a for a in _providers.ask(pol, tool, tool_input, cwd) if a.blocks]
+        if hits:
+            return Decision("confirm", "; ".join(h.text() for h in hits[:3]), path)
     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)

gitvow-0.4.0/src/gitvow/providers.py

@@ -0,0 +1,126 @@
+"""Providers: external programs the gate asks factual questions (gate_bearing, route_gate, route_callers)."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import subprocess
+from dataclasses import dataclass, field
+from typing import Any
+
+PROTOCOL = 1
+QUESTIONS = ("gate_bearing", "route_gate", "route_callers")
+EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")
+ROUTE_RE = re.compile(r"""["'`](/[A-Za-z0-9_\-./{}:*$]*)["'`]""")
+
+
+@dataclass
+class Answer:
+    provider: str
+    question: str
+    subject: str
+    answer: str  # yes | no | unknown | failed
+    evidence: list[str] = field(default_factory=list)
+
+    @property
+    def blocks(self) -> bool:
+        return self.answer in ("yes", "failed")
+
+    def text(self) -> str:
+        why = "; ".join(self.evidence[:4]) if self.evidence else ""
+        if self.answer == "failed":
+            return f"provider {self.provider} unavailable for {self.question} {self.subject}"
+        return f"provider {self.provider}: {self.question} {self.subject}" + (f": {why}" if why else "")
+
+
+def route_literals(text: str) -> list[str]:
+    """Quoted strings that look like routes: begin with '/', no spaces, at least one more character."""
+    out: list[str] = []
+    for m in ROUTE_RE.finditer(text or ""):
+        r = m.group(1)
+        if len(r) > 1 and not r.startswith("//") and "." not in os.path.basename(r) and r not in out:
+            out.append(r)
+    return out
+
+
+def questions_for(tool: str, tool_input: dict[str, Any]) -> list[tuple[str, str]]:
+    """(question, subject) pairs the gate should ask for this tool call."""
+    if tool not in EDIT_TOOLS:
+        return []
+    path = tool_input.get("file_path") or tool_input.get("notebook_path") or ""
+    qs: list[tuple[str, str]] = []
+    if path:
+        qs.append(("gate_bearing", path))
+    old, new = "", ""
+    if tool == "Edit":
+        old, new = str(tool_input.get("old_string") or ""), str(tool_input.get("new_string") or "")
+    elif tool == "MultiEdit":
+        for e in tool_input.get("edits") or []:
+            old += "\n" + str(e.get("old_string") or "")
+            new += "\n" + str(e.get("new_string") or "")
+    elif tool == "Write":
+        new = str(tool_input.get("content") or "")
+    before, after = set(route_literals(old)), set(route_literals(new))
+    qs += [("route_gate", r) for r in sorted(after - before)]
+    qs += [("route_callers", r) for r in sorted(before - after)]
+    return qs
+
+
+def _run(prov: dict[str, Any], question: str, subject: str, repo: str, path: str, tool: str) -> Answer:
+    name = str(prov.get("name") or "provider")
+    req = {
+        "protocol": PROTOCOL,
+        "question": question,
+        "subject": subject,
+        "repo": repo,
+        "path": path,
+        "tool_name": tool,
+    }
+    try:
+        argv = shlex.split(str(prov.get("command") or ""))
+        if not argv:
+            return Answer(name, question, subject, "failed", ["empty command"])
+        r = subprocess.run(
+            argv,
+            input=json.dumps(req),
+            capture_output=True,
+            text=True,
+            timeout=float(prov.get("timeout") or 10),
+            check=False,
+            cwd=repo or None,
+        )
+        if r.returncode != 0:
+            return Answer(name, question, subject, "failed", [f"exit {r.returncode}"])
+        data = json.loads(r.stdout)
+        ans = str(data.get("answer", "unknown")).lower()
+        if ans not in ("yes", "no", "unknown"):
+            return Answer(name, question, subject, "failed", ["bad answer"])
+        ev = [str(e)[:200] for e in (data.get("evidence") or [])[:8]]
+        return Answer(name, question, subject, ans, ev)
+    except (OSError, subprocess.TimeoutExpired, ValueError, AttributeError) as e:
+        return Answer(name, question, subject, "failed", [type(e).__name__])
+
+
+def ask(
+    pol: dict[str, Any],
+    tool: str,
+    tool_input: dict[str, Any],
+    cwd: str | None = None,
+    only: list[tuple[str, str]] | None = None,
+) -> list[Answer]:
+    provs = pol.get("providers") or []
+    if not provs:
+        return []
+    repo = cwd or os.getcwd()
+    path = str(tool_input.get("file_path") or tool_input.get("notebook_path") or "")
+    if path and os.path.isabs(path):
+        rel = os.path.relpath(path, repo)
+        path = rel if not rel.startswith("..") else path
+    answers: list[Answer] = []
+    for q, subj in only if only is not None else questions_for(tool, {**tool_input, "file_path": path}):
+        for prov in provs:
+            if q in (prov.get("questions") or QUESTIONS):
+                answers.append(_run(prov, q, subj, repo, path, tool))
+    return answers

{gitvow-0.3.0 → gitvow-0.4.0}/src/gitvow/selftest.py

@@ -6,6 +6,7 @@ import json
 import os
 import shutil
 import subprocess
+import sys
 import tempfile
 
 from .hooks import post_tool_use, pre_tool_use, session_start, stop
@@ -66,6 +67,24 @@ def run() -> int:
                 "deny: destructive MCP tool",
             )
         )
+        prov = (
+            f'{sys.executable} -c "import sys,json;q=json.load(sys.stdin);'
+            "print(json.dumps({'answer':'yes' if q['question']=='route_gate' else 'no',"
+            "'evidence':['route not covered by authorization (selftest provider)']}))\""
+        )
+        os.makedirs(os.path.join(repo, ".gitvow"), exist_ok=True)
+        with open(os.path.join(repo, ".gitvow", "policy.json"), "w") as fh:
+            json.dump({"providers": [{"name": "selftest", "command": prov}]}, fh)
+        code, msg = pre_tool_use(
+            {
+                **base,
+                "tool_name": "Edit",
+                "tool_input": {"file_path": "api.py", "old_string": "", "new_string": '"/v1/new"'},
+            },
+            home,
+        )
+        results.append((code == 2 and "route not covered" in msg, "confirm: provider says new route is unauthorised"))
+        os.remove(os.path.join(repo, ".gitvow", "policy.json"))
         with open(os.path.join(repo, "a.txt"), "a") as fh:
             fh.write("b\n")
         post_tool_use({**base, "tool_name": "Edit", "tool_input": {"file_path": "a.txt"}}, home)

{gitvow-0.3.0 → gitvow-0.4.0/src/gitvow.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gitvow
-Version: 0.3.0
+Version: 0.4.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.3.0 → gitvow-0.4.0}/src/gitvow.egg-info/SOURCES.txt

@@ -8,6 +8,7 @@ src/gitvow/collect.py
 src/gitvow/default_policy.json
 src/gitvow/install.py
 src/gitvow/policy.py
+src/gitvow/providers.py
 src/gitvow/redact.py
 src/gitvow/report.py
 src/gitvow/selftest.py
@@ -25,5 +26,6 @@ tests/test_hooks.py
 tests/test_install_cli.py
 tests/test_packaging.py
 tests/test_policy.py
+tests/test_providers.py
 tests/test_redact.py
 tests/test_report.py

gitvow-0.4.0/tests/test_providers.py

@@ -0,0 +1,160 @@
+import json
+import sys
+from pathlib import Path
+
+from gitvow import cli
+from gitvow.hooks import pre_tool_use
+from gitvow.policy import evaluate
+from gitvow.providers import questions_for, route_literals
+
+ROOT = Path(__file__).resolve().parents[1]
+EXAMPLE = ROOT / "examples" / "providers" / "static_facts.py"
+
+
+def test_route_literals_and_questions():
+    txt = 'a = "/v1/orders"; b = \'/v1/orders/{id}\'; c = "/static/app.js"; d = "//comment"; e = "/"; f = "/v1/orders"'
+    assert route_literals(txt) == ["/v1/orders", "/v1/orders/{id}"]
+    qs = questions_for(
+        "Edit",
+        {"file_path": "api.py", "old_string": '@app.get("/old")', "new_string": '@app.get("/new")\n@app.get("/old2")'},
+    )
+    assert qs == [
+        ("gate_bearing", "api.py"),
+        ("route_gate", "/new"),
+        ("route_gate", "/old2"),
+        ("route_callers", "/old"),
+    ]
+    assert questions_for("Write", {"file_path": "x.py", "content": 'r("/w")'}) == [
+        ("gate_bearing", "x.py"),
+        ("route_gate", "/w"),
+    ]
+    assert questions_for("Bash", {"command": 'echo "/v1/x"'}) == []
+
+
+def _facts(tmp_path):
+    f = tmp_path / "facts.json"
+    f.write_text(
+        json.dumps(
+            {
+                "gate_bearing": ["auth/AuthorizeWhitelistedPaths.java", "deploy/values/production-*.yaml"],
+                "whitelist_file": "auth/AuthorizeWhitelistedPaths.java",
+                "authorized_routes": ["/v1/orders", "/v1/orders/{id}"],
+                "callers": {"/v1/orders": ["client-orch (OrdersClient.java:88)"]},
+            }
+        )
+    )
+    return f
+
+
+def _policy(tmp_path, command):
+    return {"providers": [{"name": "facts", "command": command}]}
+
+
+def test_provider_confirms_with_evidence(tmp_path):
+    pol = _policy(tmp_path, f"{sys.executable} {EXAMPLE} --facts {_facts(tmp_path)}")
+    d = evaluate(
+        pol,
+        "Edit",
+        {"file_path": "src/api/Orders.java", "old_string": "x", "new_string": '@Path("/v1/orders/export")'},
+        str(tmp_path),
+    )
+    assert d.outcome == "confirm" and "not covered by any authorization rule" in d.reason
+    assert "AuthorizeWhitelistedPaths.java" in d.reason
+    d = evaluate(
+        pol,
+        "Edit",
+        {"file_path": "src/api/Orders.java", "old_string": "x", "new_string": '@Path("/v1/orders/{id}")'},
+        str(tmp_path),
+    )
+    assert d.outcome == "allow"  # listed as authorized
+    d = evaluate(
+        pol,
+        "Edit",
+        {"file_path": "src/api/Orders.java", "old_string": '@Path("/v1/orders")', "new_string": ""},
+        str(tmp_path),
+    )
+    assert d.outcome == "confirm" and "client-orch" in d.reason
+    d = evaluate(
+        pol,
+        "Write",
+        {"file_path": str(tmp_path / "deploy/values/production-in.yaml"), "content": "a: 1"},
+        str(tmp_path),
+    )
+    assert d.outcome == "confirm" and "gate-bearing" in d.reason
+    assert (
+        evaluate(pol, "Edit", {"file_path": "README.md", "old_string": "a", "new_string": "b"}, str(tmp_path)).outcome
+        == "allow"
+    )
+    assert evaluate(pol, "Bash", {"command": 'echo "/v1/new"'}, str(tmp_path)).outcome == "allow"
+
+
+def test_provider_failure_means_confirm(tmp_path):
+    for cmd in (
+        "/nonexistent/provider",
+        f"{sys.executable} -c \"print('not json')\"",
+        f"{sys.executable} -c 'import sys; sys.exit(3)'",
+        "",
+    ):
+        pol = _policy(tmp_path, cmd)
+        d = evaluate(pol, "Edit", {"file_path": "a.py", "old_string": "", "new_string": ""}, str(tmp_path))
+        assert d.outcome == "confirm" and "unavailable" in d.reason, cmd
+    pol = _policy(tmp_path, f"{sys.executable} -c 'import time; time.sleep(5)'")
+    pol["providers"][0]["timeout"] = 0.5
+    assert evaluate(pol, "Edit", {"file_path": "a.py"}, str(tmp_path)).outcome == "confirm"
+
+
+def test_unknown_answer_does_not_block(tmp_path):
+    pol = _policy(tmp_path, f'{sys.executable} -c "print(\'{{\\"answer\\": \\"unknown\\"}}\')"')
+    assert evaluate(pol, "Edit", {"file_path": "a.py"}, str(tmp_path)).outcome == "allow"
+
+
+def test_provider_questions_filter_and_validation(tmp_path):
+    from gitvow.policy import PolicyError, load_policy
+
+    (tmp_path / ".gitvow").mkdir()
+    (tmp_path / ".gitvow" / "policy.json").write_text(
+        json.dumps({"providers": [{"name": "x", "command": "y", "questions": ["nope"]}]})
+    )
+    try:
+        load_policy(str(tmp_path), str(tmp_path / "h"))
+        raise AssertionError("expected PolicyError")
+    except PolicyError as e:
+        assert "unknown questions" in str(e)
+    (tmp_path / ".gitvow" / "policy.json").write_text(json.dumps({"providers": [{"name": "x"}]}))
+    try:
+        load_policy(str(tmp_path), str(tmp_path / "h"))
+        raise AssertionError("expected PolicyError")
+    except PolicyError:
+        pass
+    pol = _policy(tmp_path, f"{sys.executable} {EXAMPLE} --facts {_facts(tmp_path)}")
+    pol["providers"][0]["questions"] = ["gate_bearing"]  # route questions not asked of this provider
+    d = evaluate(pol, "Edit", {"file_path": "a.py", "old_string": "", "new_string": '"/v1/zzz"'}, str(tmp_path))
+    assert d.outcome == "allow"
+
+
+def test_hook_and_cli_ask_end_to_end(repo, home, payload, tmp_path, monkeypatch, capsys):
+    facts = _facts(tmp_path)
+    (repo / ".gitvow").mkdir()
+    (repo / ".gitvow" / "policy.json").write_text(
+        json.dumps({"providers": [{"name": "facts", "command": f"{sys.executable} {EXAMPLE} --facts {facts}"}]})
+    )
+    code, msg = pre_tool_use(
+        payload(
+            "PreToolUse",
+            "Edit",
+            {"file_path": str(repo / "src/Orders.java"), "old_string": "", "new_string": '@Path("/v1/orders/export")'},
+        ),
+        str(home),
+    )
+    assert code == 2 and "CONFIRMATION REQUIRED" in msg and "AuthorizeWhitelistedPaths.java" in msg
+    log = (repo / ".git" / "gitvow-hooks.log").read_text()
+    assert '"kind": "confirm_required"' in log and "provider facts" in log
+    monkeypatch.chdir(repo)
+    assert cli.main(["ask", "route_gate", "/v1/orders/export", "--path", "src/Orders.java"]) == 2
+    out = capsys.readouterr().out
+    assert "facts: yes" in out and "decision: CONFIRM" in out
+    assert cli.main(["ask", "route_gate", "/v1/orders"]) == 0
+    assert "decision: ALLOW" in capsys.readouterr().out
+    assert cli.main(["ask", "gate_bearing", "auth/AuthorizeWhitelistedPaths.java"]) == 2
+    (repo / ".gitvow" / "policy.json").write_text("{}")
+    assert cli.main(["ask", "gate_bearing", "x"]) == 1