pr-verify 0.1.0__py3-none-any.whl

pr_verify/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pr_verify/blastradius.py

@@ -0,0 +1,179 @@
+"""Blast radius: who depends on the changed files?
+
+Builds a module import graph for the repo (Python via AST, other languages
+via heuristic regex), inverts it, and for each changed file reports the
+transitive set of dependents — the code that could break if the change is
+wrong. Standalone: no dependency on sibling packages.
+"""
+
+from __future__ import annotations
+
+import ast
+import dataclasses
+import os
+import re
+
+PY_EXTS = {".py"}
+OTHER_EXTS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+              ".go", ".rs", ".java", ".rb", ".php"}
+
+_GENERIC_IMPORT_RES = [
+    re.compile(r'^\s*import\s+(?:type\s+)?[{*]?[^"\']*?from\s+["\']([^"\']+)["\']'),
+    re.compile(r'^\s*import\s+["\']([^"\']+)["\']'),
+    re.compile(r'require\(\s*["\']([^"\']+)["\']\s*\)'),
+    re.compile(r'^\s*use\s+([a-zA-Z0-9_:]+)(?:::|\s*[{;])'),
+]
+
+
+def _imports_of(path: str, content: str) -> list[str]:
+    ext = os.path.splitext(path)[1].lower()
+    if ext in PY_EXTS:
+        try:
+            tree = ast.parse(content)
+        except SyntaxError:
+            return []
+        mods = []
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                mods.extend(a.name for a in node.names)
+            elif isinstance(node, ast.ImportFrom):
+                if node.level:
+                    mods.append("<local>")
+                elif node.module:
+                    mods.append(node.module)
+        return mods
+    if ext in OTHER_EXTS:
+        mods = []
+        for line in content.splitlines():
+            for rx in _GENERIC_IMPORT_RES:
+                m = rx.search(line)
+                if m:
+                    mods.append(m.group(1))
+                    break
+        return mods
+    return []
+
+
+def _module_candidates(rel: str) -> list[str]:
+    """Dotted forms a file might be imported as: a/b.py -> a.b, b."""
+    base = rel.replace(os.sep, "/")
+    if base.endswith("/__init__.py"):
+        dotted = base[: -len("/__init__.py")].replace("/", ".")
+    elif base.endswith(".py"):
+        dotted = base[: -len(".py")].replace("/", ".")
+    else:
+        stem = base.rsplit(".", 1)[0].replace("/", ".")
+        return [stem, stem.split(".")[-1]]
+    parts = dotted.split(".")
+    return [dotted, parts[-1]] if len(parts) > 1 else [dotted]
+
+
+@dataclasses.dataclass
+class BlastRadius:
+    file: str
+    direct: list[str]          # files directly importing it
+    transitive: list[str]      # all downstream dependents
+    external_only: bool = False  # changed file imported by nothing in-repo
+
+    @property
+    def size(self) -> int:
+        return len(self.transitive)
+
+
+def _iter_files(root: str) -> list[str]:
+    skip = {".git", "node_modules", "__pycache__", ".venv", "venv",
+            "dist", "build", ".tox", "vendor"}
+    out = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in skip]
+        for fn in filenames:
+            if os.path.splitext(fn)[1].lower() in (PY_EXTS | OTHER_EXTS):
+                out.append(os.path.join(dirpath, fn))
+    return sorted(out)
+
+
+def build_graph(root: str) -> dict[str, set[str]]:
+    """rel path -> set of rel paths it imports (in-repo only)."""
+    files = _iter_files(root)
+    rels = [os.path.relpath(p, root).replace(os.sep, "/") for p in files]
+    # index: dotted name -> rel
+    index: dict[str, str] = {}
+    for rel in rels:
+        for cand in _module_candidates(rel):
+            index.setdefault(cand, rel)
+    graph: dict[str, set[str]] = {rel: set() for rel in rels}
+    for path, rel in zip(files, rels):
+        try:
+            with open(path, encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except OSError:
+            continue
+        for mod in _imports_of(path, content):
+            target = index.get(mod)
+            if target and target != rel:
+                graph[rel].add(target)
+    return graph
+
+
+def dependents_of_modules(root: str, module_names: set[str]) -> list[str]:
+    """rel paths in the current worktree importing any of module_names.
+
+    Used for changed files absent from the worktree (e.g. deleted files):
+    the normal graph can't resolve them, so match the raw imported module
+    strings instead. Over-approximates on bare-name matches (e.g. "core");
+    for a trust tool, flagging a possibly-broken dependent beats silence.
+    """
+    if not module_names:
+        return []
+    out = []
+    for path in _iter_files(root):
+        rel = os.path.relpath(path, root).replace(os.sep, "/")
+        try:
+            with open(path, encoding="utf-8", errors="replace") as f:
+                content = f.read()
+        except OSError:
+            continue
+        if set(_imports_of(path, content)) & module_names:
+            out.append(rel)
+    return sorted(out)
+
+
+def _transitive_dependents(reverse: dict[str, set[str]],
+                           direct: list[str], rel: str) -> list[str]:
+    seen = set(direct)
+    stack = list(direct)
+    while stack:
+        cur = stack.pop()
+        for nxt in reverse.get(cur, ()):
+            if nxt not in seen:
+                seen.add(nxt)
+                stack.append(nxt)
+    seen.discard(rel)
+    return sorted(seen)
+
+
+def analyze(root: str, changed: list[str]) -> dict[str, BlastRadius]:
+    graph = build_graph(root)
+    # invert
+    reverse: dict[str, set[str]] = {rel: set() for rel in graph}
+    for src, deps in graph.items():
+        for dep in deps:
+            reverse[dep].add(src)
+    result: dict[str, BlastRadius] = {}
+    for rel in changed:
+        if rel in reverse:
+            direct = sorted(reverse[rel])
+            transitive = _transitive_dependents(reverse, direct, rel)
+            result[rel] = BlastRadius(file=rel, direct=direct,
+                                      transitive=transitive)
+            continue
+        # Not in the worktree graph (deleted or unknown file): fall back
+        # to matching the file's module names against the raw imports of
+        # every file still in the worktree, so deleted imports still show
+        # their (now broken) dependents.
+        direct = dependents_of_modules(root, set(_module_candidates(rel)))
+        transitive = _transitive_dependents(reverse, direct, rel)
+        result[rel] = BlastRadius(file=rel, direct=direct,
+                                  transitive=transitive,
+                                  external_only=not direct)
+    return result

pr_verify/cli.py

@@ -0,0 +1,178 @@
+"""PR Verify: deterministic trust for agent-authored PRs.
+
+Not another AI reviewer — verification, not opinion. For a diff range it
+reports: which lines an agent wrote (provenance), what could break
+(blast radius), whether policy gates pass, and a deterministic risk score
+that tells a senior how deep to review.
+
+  pr-verify check --base main
+  pr-verify check --base origin/main --format json --fail-on high
+  pr-verify init   # write an example .pr-verify.yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+
+from . import blastradius as br_mod
+from . import config as config_mod
+from . import gates as gates_mod
+from . import provenance as prov_mod
+from . import risk as risk_mod
+
+VERSION = "0.1.0"
+
+
+def _ensure_repo(root: str) -> None:
+    p = subprocess.run(["git", "-C", root, "rev-parse", "--git-dir"],
+                       capture_output=True, timeout=15)
+    if p.returncode != 0:
+        print("error: not a git repo", file=sys.stderr)
+        sys.exit(2)
+
+
+def cmd_init(args) -> int:
+    path = os.path.join(args.root, config_mod.CONFIG_FILE)
+    if os.path.exists(path) and not args.force:
+        print(f"{config_mod.CONFIG_FILE} exists (use --force).")
+        return 2
+    with open(path, "w") as f:
+        f.write(config_mod.example_config())
+    print(f"wrote {config_mod.CONFIG_FILE} — tune markers, paths, gates.")
+    return 0
+
+
+def _report_human(prov, blast, gate_results, breakdown, threshold) -> None:
+    total_added = sum(f.added for f in prov.values())
+    agent_added = sum(f.agent_added for f in prov.values())
+    print("═" * 56)
+    print(f"  PR VERIFY  risk {breakdown.score}/100 "
+          f"({breakdown.band.upper()})")
+    print("═" * 56)
+    print(f"\n  provenance: {agent_added}/{total_added} added lines "
+          f"agent-authored")
+    for rel in sorted(prov):
+        f = prov[rel]
+        if f.deleted:
+            who = ", ".join(f.deleted_by) or "unknown"
+            print(f"    deleted  {rel} (deleted by {who})")
+        elif f.added:
+            who = ",".join(sorted(f.agents)) if f.agents else "human"
+            print(f"    {f.label():6}  {rel} "
+                  f"({f.agent_added}/{f.added} agent) [{who}]")
+    print("\n  blast radius:")
+    ranked = sorted(blast.values(), key=lambda b: b.size, reverse=True)[:8]
+    if not ranked:
+        print("    no files changed")
+    for b in ranked:
+        print(f"    {b.file}: {b.size} downstream dependent(s)")
+        if b.direct:
+            print(f"      direct: {', '.join(b.direct[:5])}"
+                  + (" …" if len(b.direct) > 5 else ""))
+    print("\n  gates:")
+    if not gate_results:
+        print("    none configured")
+    for g in gate_results:
+        mark = "PASS" if g.passed else ("TIMEOUT" if g.timed_out else "FAIL")
+        print(f"    [{mark}] {g.command}")
+    print("\n  risk factors:")
+    for name, fac in breakdown.factors.items():
+        print(f"    {fac['points']:>3} pts  {name:12} {fac['detail']}")
+    print()
+    if breakdown.requires_review:
+        print(f"  ✗ score {breakdown.score} >= threshold {threshold}: "
+              "needs senior review")
+    else:
+        print(f"  ✓ score {breakdown.score} < threshold {threshold}")
+    print("═" * 56)
+
+
+def cmd_check(args) -> int:
+    root = args.root
+    _ensure_repo(root)
+    cfg = config_mod.load(root, args.base)
+
+    # Default head (HEAD) also verifies uncommitted working-tree changes:
+    # snapshot them into a synthetic commit so diff/blame see everything.
+    # An explicit --head means "committed range only".
+    head = args.head
+    if head == "HEAD":
+        snap = prov_mod.snapshot_worktree(root)
+        if snap:
+            head = snap
+    prov = prov_mod.analyze(root, args.base, head,
+                            cfg["agent_markers"])
+    if not prov:
+        print(f"no added lines in {args.base}..{args.head} — nothing to verify")
+        return 0
+    blast = br_mod.analyze(root, list(prov.keys()))
+    gate_results = (gates_mod.run_gates(root, cfg["gates"], cfg["timeout"])
+                    if not args.skip_gates else [])
+    breakdown = risk_mod.score(prov, blast, gate_results,
+                               cfg["sensitive_paths"],
+                               cfg["risk_threshold"])
+
+    if args.format == "json":
+        out = {
+            "tool": "pr-verify", "version": VERSION,
+            "base": args.base, "head": args.head,
+            "risk": breakdown.as_dict(),
+            "files": {
+                rel: {"added": f.added, "agent_added": f.agent_added,
+                      "label": f.label(), "agents": sorted(f.agents),
+                      "deleted": f.deleted, "deleted_by": f.deleted_by}
+                for rel, f in prov.items()},
+            "blast_radius": {
+                rel: {"direct": b.direct, "transitive": b.transitive}
+                for rel, b in blast.items()},
+            "gates": [g.as_dict() for g in gate_results],
+        }
+        print(json.dumps(out, indent=2))
+    else:
+        _report_human(prov, blast, gate_results, breakdown,
+                      cfg["risk_threshold"])
+
+    if any(not g.passed for g in gate_results):
+        # A failing policy gate is a failed verification, independent of
+        # --fail-on: the tool cannot vouch for this diff.
+        return 1
+    if args.fail_on == "high" and breakdown.requires_review:
+        return 1
+    if args.fail_on == "any-risk" and breakdown.score > 0:
+        return 1
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="pr-verify", description=__doc__)
+    p.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+    p.add_argument("--root", default=os.getcwd())
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    i = sub.add_parser("init", help="Write example .pr-verify.yaml.")
+    i.add_argument("--force", action="store_true")
+
+    c = sub.add_parser("check", help="Verify a diff range.")
+    c.add_argument("--base", default="main",
+                   help="Base ref (default: main).")
+    c.add_argument("--head", default="HEAD",
+                   help="Head ref (default: HEAD, uncommitted "
+                        "working-tree changes included).")
+    c.add_argument("--format", choices=["human", "json"], default="human")
+    c.add_argument("--fail-on", choices=["high", "any-risk", "never"],
+                   default="high")
+    c.add_argument("--skip-gates", action="store_true")
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    return {"init": cmd_init, "check": cmd_check}[args.cmd](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pr_verify/config.py

@@ -0,0 +1,83 @@
+"""Config: .pr-verify.yaml — markers, sensitive paths, gates, thresholds.
+
+Security: the config is read from the BASE REF (the trusted side of the
+diff), never from the worktree. A hostile PR must not be able to ship its
+own gate config and get it executed on the reviewer's/CI machine.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+
+from . import miniyaml
+
+CONFIG_FILE = ".pr-verify.yaml"
+
+DEFAULTS = {
+    # Substrings matched (case-insensitive) against commit author name/email
+    # and message to classify a commit as agent-authored.
+    "agent_markers": [
+        "claude", "codex", "cursor", "copilot", "bot",
+        "co-authored-by: claude", "aider", "cody",
+    ],
+    # Globs (repo-relative) for security-sensitive areas.
+    "sensitive_paths": [
+        "**/auth*/**", "**/*auth*.py",
+        "**/crypto*/**", "**/*crypt*.py",
+        "**/payment*/**", "**/billing*/**",
+        "**/migrations/**", "**/migrate/**",
+        "**/*secret*", "**/*password*", "**/*token*", "**/*key*.py",
+    ],
+    # Policy gates: commands run from the repo root, WITHOUT a shell
+    # (each command is split with shlex into an argv list). Keep them to
+    # plain executables with arguments — no pipes, redirects, or $VARs.
+    "gates": [],
+    # "gates": ["python -m pytest -x -q"],
+    "risk_threshold": 70,   # >= this => exit 1 (needs senior review)
+    "timeout": 300,         # seconds per gate
+}
+
+
+def _read_base_config(root: str, base: str) -> dict:
+    """Return the parsed config file as committed at <base>, or {}."""
+    p = subprocess.run(
+        ["git", "-C", root, "show", f"{base}:{CONFIG_FILE}"],
+        capture_output=True, text=True, timeout=15)
+    if p.returncode != 0:
+        return {}
+    try:
+        return miniyaml.safe_load(p.stdout) or {}
+    except ValueError as e:
+        raise RuntimeError(
+            f"invalid {CONFIG_FILE} at {base}: {e} "
+            f"(supported: plain mappings/lists/scalars, no anchors or "
+            f"multi-line scalars)") from e
+
+
+def load(root: str, base: str) -> dict:
+    cfg = dict(DEFAULTS)
+    for key, val in _read_base_config(root, base).items():
+        cfg[key] = val
+    # normalize marker matching inputs
+    cfg["agent_markers"] = [m.lower() for m in cfg.get("agent_markers", [])]
+    return cfg
+
+
+def example_config() -> str:
+    return """# PR Verify config. All fields optional; shown with defaults.
+agent_markers:
+  - claude
+  - codex
+  - cursor
+  - copilot
+  - bot
+sensitive_paths:
+  - "**/auth*/**"
+  - "**/migrations/**"
+  - "**/*secret*"
+gates:
+  - "python -m pytest -x -q"
+risk_threshold: 70
+timeout: 300
+"""

pr_verify/gates.py

@@ -0,0 +1,63 @@
+"""Policy gates: run configured commands, capture pass/fail.
+
+Security: commands are executed WITHOUT a shell. Each gate string is
+split with shlex into an argv list and run directly, so shell
+metacharacters (;, &&, $(), backticks, pipes) are passed as literal
+arguments and never interpreted. Gate config itself is loaded from the
+base ref (see config.py), never from the worktree under review.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import shlex
+import subprocess
+
+
+@dataclasses.dataclass
+class GateResult:
+    command: str
+    passed: bool
+    returncode: int
+    output_tail: str
+    timed_out: bool = False
+
+    def as_dict(self) -> dict:
+        return dataclasses.asdict(self)
+
+
+def run_gates(root: str, commands: list[str],
+              timeout: int = 300) -> list[GateResult]:
+    results: list[GateResult] = []
+    for cmd in commands:
+        if not cmd or not cmd.strip():
+            continue
+        argv = shlex.split(cmd)
+        if not argv:
+            continue
+        try:
+            p = subprocess.run(argv, shell=False, cwd=root,
+                               capture_output=True, text=True,
+                               timeout=timeout)
+            tail = (p.stdout + p.stderr)[-2000:]
+            results.append(GateResult(
+                command=cmd, passed=p.returncode == 0,
+                returncode=p.returncode, output_tail=tail))
+        except subprocess.TimeoutExpired as e:
+            out = ""
+            if e.stdout:
+                out += e.stdout.decode(errors="replace") \
+                    if isinstance(e.stdout, bytes) else e.stdout
+            if e.stderr:
+                err = e.stderr.decode(errors="replace") \
+                    if isinstance(e.stderr, bytes) else e.stderr
+                out += err
+            results.append(GateResult(
+                command=cmd, passed=False, returncode=-1,
+                output_tail=out[-2000:], timed_out=True))
+        except (OSError, ValueError) as e:
+            # argv[0] not found / not executable: a failed gate, not a crash.
+            results.append(GateResult(
+                command=cmd, passed=False, returncode=127,
+                output_tail=f"gate could not run: {e}"[-2000:]))
+    return results

pr_verify/miniyaml.py

@@ -0,0 +1,273 @@
+"""Minimal YAML subset parser (stdlib only).
+
+Handles the subset these tools need:
+  - block mappings and lists, nested by indentation
+  - inline-map list items ("- key: value")
+  - flow-style lists of scalars ("[a, b]")
+  - scalars: quoted strings, ints, floats, bools, null
+  - "#" comments (outside quotes)
+
+SHARED COPY: the canonical version lives here in adr_drift/miniyaml.py.
+pr_verify and promptregress carry verbatim copies (see their headers).
+Do not fork — fix the canonical copy and re-copy.
+
+NOT supported (raises ValueError): anchors, aliases, tags, multi-line
+(|, >) scalars, flow maps, duplicate keys. Configs using them get a
+clear error naming the feature and the line number.
+
+Strictness notes:
+  - Every ValueError carries a line number: "miniyaml: <what> (line N)".
+  - Unclosed flow lists ("a: [x"), embedded mapping indicators
+    ("a: b: c"), unterminated quotes, and nested flow collections are
+    rejected instead of silently misparsed.
+  - Nesting deeper than MAX_DEPTH (50) raises ValueError, never
+    RecursionError.
+"""
+
+from __future__ import annotations
+
+import re
+
+_KEY_RE = re.compile(r"^([A-Za-z0-9_.\-/ ]+):(?:\s|$)")
+
+#: Deepest block-nesting level accepted. Deeper input raises ValueError
+#: (the parser's error contract) instead of RecursionError.
+MAX_DEPTH = 50
+
+
+def _err(msg: str, lineno: int) -> ValueError:
+    return ValueError(f"miniyaml: {msg} (line {lineno})")
+
+
+def _strip_comment(line: str) -> str:
+    in_s = in_d = False
+    for i, ch in enumerate(line):
+        if ch == "'" and not in_d:
+            in_s = not in_s
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+        elif ch == "#" and not in_s and not in_d:
+            if i == 0 or line[i - 1] in " \t":
+                return line[:i]
+    return line
+
+
+def _scalar(s: str):
+    s = s.strip()
+    if len(s) >= 2 and s[0] == s[-1] and s[0] in "\"'":
+        inner = s[1:-1]
+        if s[0] == '"':
+            inner = inner.replace('\\"', '"').replace("\\\\", "\\")
+        return inner
+    low = s.lower()
+    if low in ("null", "~", "none", ""):
+        return None
+    if low in ("true", "yes", "on"):
+        return True
+    if low in ("false", "no", "off"):
+        return False
+    try:
+        return int(s)
+    except ValueError:
+        pass
+    try:
+        return float(s)
+    except ValueError:
+        pass
+    return s
+
+
+def _check_no_mapping_indicator(v: str, lineno: int):
+    """Reject ':' inside a plain scalar ("a: b: c") — PyYAML rejects it too.
+
+    v is an unquoted scalar here; stray quote chars are tracked so a
+    colon inside e.g. "it's: fine" does not false-positive.
+    """
+    in_s = in_d = False
+    for i, ch in enumerate(v):
+        if ch == "'" and not in_d:
+            in_s = not in_s
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+        elif ch == ":" and not in_s and not in_d:
+            nxt = v[i + 1] if i + 1 < len(v) else ""
+            if nxt in ("", " ", "\t"):
+                raise _err(
+                    "unexpected ':' in scalar "
+                    f"(nested mappings need their own lines): {v!r}",
+                    lineno,
+                )
+
+
+def _check_value(val: str, lineno: int, in_flow: bool = False):
+    """Reject unsupported/malformed value shapes before _scalar() sees them.
+
+    Anchors (&), aliases (*), and tags (!) are named explicitly so a
+    config using them fails loudly instead of silently dropping content.
+    """
+    v = val.strip()
+    if not v:
+        return
+    c0 = v[0]
+    if c0 == "&":
+        raise _err("YAML anchors (&) are not supported", lineno)
+    if c0 == "*":
+        raise _err("YAML aliases (*) are not supported", lineno)
+    if c0 == "!":
+        raise _err("YAML tags (!) are not supported", lineno)
+    if c0 in ("|", ">"):
+        raise _err("multi-line (|, >) scalars are not supported", lineno)
+    if c0 in "\"'":
+        # Quoted scalars are opaque — nothing else to check.
+        if len(v) < 2 or v[-1] != c0:
+            raise _err(f"unterminated quoted string: {v!r}", lineno)
+        return
+    if c0 == "{":
+        raise _err("flow-style maps ({...}) are not supported", lineno)
+    if c0 == "[":
+        if in_flow:
+            raise _err("nested flow collections are not supported", lineno)
+        if not v.endswith("]"):
+            raise _err(f"unclosed flow list: {v!r}", lineno)
+        return  # balanced "[...]"; items are checked per-item in _flow_list
+    if in_flow and any(ch in v for ch in "[]{}"):
+        raise _err("nested flow collections are not supported", lineno)
+    _check_no_mapping_indicator(v, lineno)
+
+
+def _flow_list(s: str, lineno: int) -> list:
+    """Parse [a, b, "c"] — scalars only."""
+    inner = s.strip()[1:-1].strip()
+    if not inner:
+        return []
+    raw_items, cur, in_s, in_d = [], "", False, False
+    for ch in inner:
+        if ch == "'" and not in_d:
+            in_s = not in_s
+            cur += ch
+        elif ch == '"' and not in_s:
+            in_d = not in_d
+            cur += ch
+        elif ch == "," and not in_s and not in_d:
+            raw_items.append(cur)
+            cur = ""
+        else:
+            cur += ch
+    if in_s or in_d:
+        raise _err(f"unterminated quote in flow list: {s}", lineno)
+    raw_items.append(cur)
+    out = []
+    for item in raw_items:
+        _check_value(item, lineno, in_flow=True)
+        out.append(_scalar(item))
+    return out
+
+
+def safe_load(text: str):
+    # items: (line number, indent, content)
+    items = []
+    for lineno, raw in enumerate(text.splitlines(), 1):
+        line = _strip_comment(raw).rstrip()
+        if not line.strip():
+            continue
+        if "\t" in line[: len(line) - len(line.lstrip())]:
+            raise _err("tabs not allowed for indentation", lineno)
+        indent = len(line) - len(line.lstrip(" "))
+        content = line.strip()
+        if content in ("---", "..."):
+            continue
+        items.append((lineno, indent, content))
+    if not items:
+        return None
+    val, pos = _parse_block(items, 0, items[0][1], 0)
+    if pos != len(items):
+        lineno, _, content = items[pos]
+        raise _err(f"unexpected content: {content!r}", lineno)
+    return val
+
+
+def _parse_block(items, pos, indent, depth):
+    if depth > MAX_DEPTH:
+        raise _err(
+            f"maximum nesting depth ({MAX_DEPTH}) exceeded", items[pos][0]
+        )
+    first = items[pos][2]
+    if first == "-" or first.startswith("- "):
+        return _parse_list(items, pos, indent, depth)
+    return _parse_map(items, pos, indent, depth)
+
+
+def _parse_map(items, pos, indent, depth):
+    d: dict = {}
+    while pos < len(items):
+        lineno, ind, line = items[pos]
+        if ind < indent:
+            break
+        if ind > indent:
+            raise _err(f"bad indentation: {line!r}", lineno)
+        if line == "-" or line.startswith("- "):
+            raise _err(f"list item inside mapping: {line!r}", lineno)
+        if line[0] in "&*!":
+            # Anchor/alias/tag where a key was expected — name it.
+            _check_value(line, lineno)
+        m = _KEY_RE.match(line)
+        if not m:
+            raise _err(f"expected 'key: value', got: {line!r}", lineno)
+        key = m.group(1).strip()
+        rest = line[m.end():].strip()
+        pos += 1
+        if key in d:
+            raise _err(f"duplicate key: {key!r}", lineno)
+        if rest:
+            _check_value(rest, lineno)
+            if rest.startswith("["):
+                d[key] = _flow_list(rest, lineno)
+            else:
+                d[key] = _scalar(rest)
+        else:
+            if pos < len(items) and items[pos][1] > indent:
+                val, pos = _parse_block(items, pos, items[pos][1], depth + 1)
+                d[key] = val
+            else:
+                d[key] = None
+    return d, pos
+
+
+def _parse_list(items, pos, indent, depth):
+    lst: list = []
+    while pos < len(items):
+        lineno, ind, line = items[pos]
+        if ind < indent:
+            break
+        if ind > indent:
+            raise _err(f"bad indentation: {line!r}", lineno)
+        if not (line == "-" or line.startswith("- ")):
+            break  # end of list; parent map continues
+        content = line[1:].strip()
+        pos += 1
+        if not content:
+            if pos < len(items) and items[pos][1] > indent:
+                val, pos = _parse_block(items, pos, items[pos][1], depth + 1)
+                lst.append(val)
+            else:
+                lst.append(None)
+            continue
+        if _KEY_RE.match(content):
+            sub = [(lineno, indent + 2, content)]
+            while pos < len(items) and items[pos][1] > indent:
+                sub.append(items[pos])
+                pos += 1
+            val, _ = _parse_map(sub, 0, indent + 2, depth + 1)
+            lst.append(val)
+        elif content.startswith("[") and content.endswith("]"):
+            _check_value(content, lineno)
+            lst.append(_flow_list(content, lineno))
+        else:
+            _check_value(content, lineno)
+            lst.append(_scalar(content))
+    return lst, pos
+
+
+# alias mirroring the PyYAML call sites being replaced
+def load(text: str):
+    return safe_load(text)

pr_verify/provenance.py

@@ -0,0 +1,225 @@
+"""Provenance: which added lines were written by an agent vs a human.
+
+Method (deterministic, no LLM):
+  1. `git diff -U0 base..head` -> added lines per file (hunks).
+  2. `git blame --porcelain <head> -- <file>` -> commit per line.
+  3. `git log` for those commits -> author name/email + subject/body.
+  4. A commit is agent-authored if any agent_marker substring appears in
+     the author name, author email, subject, or body (case-insensitive).
+
+Deleted files are reported too: `git diff --diff-filter=D` finds them and
+`git log --diff-filter=D` identifies the deleting commit(s), so a deletion
+can never slip through as "nothing to verify". For a deleted file the
+blast-radius scan matches the file's module names against the imports of
+the files still in the worktree.
+
+snapshot_worktree() commits the current index+worktree (including
+untracked files) to a synthetic, ref-less commit so `check` also sees
+uncommitted changes. Uncommitted lines are attributed to a neutral
+"pr-verify (worktree)" identity — i.e. counted as human, never as agent —
+because there is no commit authorship to analyze.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import os
+import re
+import subprocess
+import tempfile
+
+
+def _git(root: str, *args: str, env: dict | None = None) -> str:
+    p = subprocess.run(["git", "-C", root, *args], capture_output=True,
+                       text=True, timeout=60, env=env)
+    if p.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {p.stderr.strip()[:200]}")
+    return p.stdout
+
+
+def snapshot_worktree(root: str) -> str | None:
+    """Synthetic commit of index+worktree (untracked included).
+
+    Returns the new commit sha, or None when there is nothing to snapshot
+    (no HEAD yet, or any git plumbing failure — callers fall back to the
+    plain head ref). Touches no refs and no user-visible index: staging
+    happens in a temporary GIT_INDEX_FILE that is removed afterwards.
+    """
+    try:
+        head = _git(root, "rev-parse", "--verify", "HEAD").strip()
+    except RuntimeError:
+        return None
+    env = dict(os.environ)
+    env.update({
+        "GIT_AUTHOR_NAME": "pr-verify (worktree)",
+        "GIT_AUTHOR_EMAIL": "pr-verify@local",
+        "GIT_COMMITTER_NAME": "pr-verify (worktree)",
+        "GIT_COMMITTER_EMAIL": "pr-verify@local",
+    })
+    fd, idx = tempfile.mkstemp(prefix="pr-verify-index-")
+    os.close(fd)
+    env["GIT_INDEX_FILE"] = idx
+    try:
+        for args in (["read-tree", "HEAD"], ["add", "-A"]):
+            p = subprocess.run(["git", "-C", root, *args], env=env,
+                               capture_output=True, timeout=60)
+            if p.returncode != 0:
+                return None
+        p = subprocess.run(["git", "-C", root, "write-tree"], env=env,
+                           capture_output=True, text=True, timeout=60)
+        if p.returncode != 0:
+            return None
+        tree = p.stdout.strip()
+        p = subprocess.run(
+            ["git", "-C", root, "commit-tree", tree,
+             "-p", head, "-m", "pr-verify: uncommitted worktree snapshot"],
+            env=env, capture_output=True, text=True, timeout=60)
+        if p.returncode != 0:
+            return None
+        return p.stdout.strip()
+    finally:
+        try:
+            os.unlink(idx)
+        except OSError:
+            pass
+
+
+@dataclasses.dataclass
+class FileProvenance:
+    file: str
+    added: int = 0
+    agent_added: int = 0
+    human_added: int = 0
+    agents: set = dataclasses.field(default_factory=set)  # author names
+    deleted: bool = False
+    deleted_by: list = dataclasses.field(default_factory=list)  # author names
+
+    @property
+    def agent_share(self) -> float:
+        return self.agent_added / self.added if self.added else 0.0
+
+    def label(self) -> str:
+        if self.deleted:
+            return "deleted"
+        if self.added == 0:
+            return "untouched"
+        if self.agent_added == self.added:
+            return "agent"
+        if self.agent_added == 0:
+            return "human"
+        return "mixed"
+
+
+_DIFF_HUNK_RE = re.compile(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@")
+
+
+def added_lines(root: str, base: str, head: str = "HEAD") -> dict[str, list[int]]:
+    """Repo-relative file -> sorted list of added line numbers (at head)."""
+    out = _git(root, "diff", "-U0", f"{base}..{head}", "--")
+    result: dict[str, list[int]] = {}
+    cur_file: str | None = None
+    new_line = 0
+    for line in out.splitlines():
+        if line.startswith("+++ b/"):
+            cur_file = line[6:]
+            result.setdefault(cur_file, [])
+        elif line.startswith("@@"):
+            m = _DIFF_HUNK_RE.match(line)
+            if m and cur_file:
+                new_line = int(m.group(1))
+        elif cur_file and new_line:
+            if line.startswith("+") and not line.startswith("+++"):
+                result[cur_file].append(new_line)
+                new_line += 1
+            elif line.startswith("-") and not line.startswith("---"):
+                pass  # removed line: doesn't advance new-file numbering
+            else:
+                new_line += 1
+    return {f: sorted(ls) for f, ls in result.items() if ls}
+
+
+def deleted_files(root: str, base: str, head: str = "HEAD") -> list[str]:
+    """Repo-relative paths deleted between base and head."""
+    out = _git(root, "diff", "--name-only", "--diff-filter=D",
+               f"{base}..{head}", "--")
+    return sorted(p for p in out.splitlines() if p)
+
+
+def _deletion_commits(root: str, base: str, head: str,
+                      rel: str) -> list[str]:
+    """Commit shas in base..head that deleted rel (oldest first)."""
+    out = _git(root, "log", "--format=%H", "--diff-filter=D", "--reverse",
+               f"{base}..{head}", "--", rel)
+    return [ln for ln in out.splitlines() if ln]
+
+
+def _blame_authors(root: str, head: str, rel: str) -> dict[int, str]:
+    """Line number -> commit sha, for <head> version of file."""
+    out = _git(root, "blame", "--porcelain", head, "--", rel)
+    authors: dict[int, str] = {}
+    sha = ""
+    lineno = 0
+    for line in out.splitlines():
+        if re.match(r"^[0-9a-f]{40} \d+ \d+ \d+$", line):
+            parts = line.split()
+            sha, lineno = parts[0], int(parts[2])
+        elif line.startswith("\t"):
+            authors[lineno] = sha
+            lineno += 1  # each content line advances within the hunk
+    return authors
+
+
+def _commit_text(root: str, shas: set[str]) -> dict[str, tuple[str, str]]:
+    """sha -> (author name, 'name email subject body' lowercased)."""
+    infos: dict[str, tuple[str, str]] = {}
+    for sha in shas:
+        out = _git(root, "log", "-1", "--format=%an%x00%ae%x00%s%x00%b", sha)
+        parts = out.split("\x00")
+        name = parts[0] if parts else sha[:7]
+        infos[sha] = (name, " ".join(parts).lower())
+    return infos
+
+
+def analyze(root: str, base: str, head: str = "HEAD",
+            agent_markers: list[str] | None = None) -> dict[str, FileProvenance]:
+    agent_markers = [m.lower() for m in (agent_markers or [])]
+    added = added_lines(root, base, head)
+    deleted = deleted_files(root, base, head)
+    result: dict[str, FileProvenance] = {}
+    # Batch: collect all shas first, then one log per sha.
+    blame_maps: dict[str, dict[int, str]] = {}
+    del_shas: dict[str, list[str]] = {}
+    all_shas: set[str] = set()
+    for rel in added:
+        bm = _blame_authors(root, head, rel)
+        blame_maps[rel] = bm
+        all_shas.update(bm[ln] for ln in added[rel] if ln in bm)
+    for rel in deleted:
+        shas = _deletion_commits(root, base, head, rel)
+        del_shas[rel] = shas
+        all_shas.update(shas)
+    texts = _commit_text(root, all_shas)
+    agent_shas = {s for s, (_name, t) in texts.items()
+                  if any(m in t for m in agent_markers)}
+
+    for rel, linenos in added.items():
+        fp = FileProvenance(file=rel)
+        bm = blame_maps[rel]
+        for ln in linenos:
+            fp.added += 1
+            sha = bm.get(ln)
+            if sha in agent_shas:
+                fp.agent_added += 1
+                fp.agents.add(texts[sha][0] or sha[:7])
+            else:
+                fp.human_added += 1
+        result[rel] = fp
+    for rel in deleted:
+        fp = FileProvenance(file=rel, deleted=True)
+        for sha in del_shas[rel]:
+            name = texts.get(sha, (sha[:7], ""))[0] or sha[:7]
+            fp.deleted_by.append(name)
+            if sha in agent_shas:
+                fp.agents.add(name)
+        result[rel] = fp
+    return result

pr_verify/risk.py

@@ -0,0 +1,160 @@
+"""Risk scoring: deterministic, documented, no LLM.
+
+Score 0-100 from six observable factors. The formula is public so teams
+can argue with it and tune it — a black-box score is just another opinion.
+
+  agent_share  40 pts  % of added lines written by an agent (provenance)
+  blast        25 pts  log-scaled transitive dependents: 25 * min(1, log10(1+n)/2)
+                      (n=9 -> ~12.5, n=99 -> 25)
+  sensitive    20 pts  any changed file under a sensitive_path glob
+                      (deleted files match like touched files)
+  gates        10 pts  any policy gate failed or timed out (0 if no gates)
+  no_tests      5 pts  src changed but no test file changed
+  deletion     50 pts  agent-attributed deletions: 45 if any deleted file
+                      matches a sensitive_path glob (deleting sensitive
+                      code, not touching it), else 10 for any agent
+                      deletion of tracked files; plus blast-radius-style
+                      points for the deleted files' transitive dependents
+                      (25 * min(1, log10(1+n)/2)), capped at 50.
+                      A pure-deletion PR previously capped at ~50 and could
+                      never trip the high threshold; deleting auth.py is at
+                      least as scary as rewriting it.
+
+Bands: 0-29 low · 30-69 medium · 70-100 high (needs senior review).
+"""
+
+from __future__ import annotations
+
+import dataclasses
+import fnmatch
+import math
+import os
+
+from . import blastradius as br_mod
+from . import gates as gates_mod
+from . import provenance as prov_mod
+
+
+@dataclasses.dataclass
+class RiskBreakdown:
+    score: int
+    band: str
+    factors: dict  # name -> {"points": int, "detail": str}
+    requires_review: bool
+
+    def as_dict(self) -> dict:
+        return {"score": self.score, "band": self.band,
+                "factors": self.factors,
+                "requires_review": self.requires_review}
+
+
+def _is_test_file(rel: str) -> bool:
+    low = rel.lower()
+    return ("test" in low.split("/")[-1] or "/tests/" in low
+            or low.startswith("tests/"))
+
+
+def _sensitive_candidates(f: str) -> list[str]:
+    # Globs are matched against the full repo-relative path AND the
+    # bare filename, so a pattern like "*auth*" catches auth.py at the
+    # repo root or nested anywhere — not just under matched directories.
+    base = os.path.basename(f)
+    return [f, "/" + f, base, "/" + base]
+
+
+def _sensitive_hits(files: list[str], sensitive_paths: list[str]) -> list[str]:
+    return sorted({f for f in files
+                   if any(fnmatch.fnmatchcase(c, p)
+                          for c in _sensitive_candidates(f)
+                          for p in sensitive_paths)})
+
+
+def _blast_points(n: int, cap: int) -> int:
+    """Log-scaled dependents -> points, shared by blast and deletion."""
+    return round(cap * min(1.0, math.log10(1 + n) / 2)) if n else 0
+
+
+def score(prov: dict[str, prov_mod.FileProvenance],
+          blast: dict[str, br_mod.BlastRadius],
+          gate_results: list[gates_mod.GateResult],
+          sensitive_paths: list[str],
+          threshold: int) -> RiskBreakdown:
+    factors: dict[str, dict] = {}
+
+    total_added = sum(f.added for f in prov.values())
+    agent_added = sum(f.agent_added for f in prov.values())
+    share = agent_added / total_added if total_added else 0.0
+    pts = round(share * 40)
+    factors["agent_share"] = {
+        "points": pts,
+        "detail": f"{agent_added}/{total_added} added lines agent-authored "
+                  f"({share:.0%})"}
+
+    max_n = max((b.size for b in blast.values()), default=0)
+    pts = _blast_points(max_n, 25)
+    factors["blast"] = {
+        "points": pts,
+        "detail": f"largest blast radius: {max_n} downstream dependent(s)"}
+
+    # Deleted files match the sensitive globs like touched files do —
+    # deleting auth.py is not a way to dodge the sensitive factor.
+    sens_hits = _sensitive_hits(list(prov), sensitive_paths)
+    pts = 20 if sens_hits else 0
+    factors["sensitive"] = {
+        "points": pts,
+        "detail": f"sensitive files touched: {', '.join(sens_hits) or 'none'}"}
+
+    failed = [g.command for g in gate_results
+              if not g.passed]
+    pts = 10 if failed else 0
+    factors["gates"] = {
+        "points": pts,
+        "detail": (f"failed gates: {', '.join(failed)}"
+                   if failed else
+                   f"{len(gate_results)} gate(s) passed"
+                   if gate_results else "no gates configured")}
+
+    src_changed = any(not _is_test_file(f) for f in prov)
+    tests_changed = any(_is_test_file(f) for f in prov)
+    pts = 5 if (src_changed and not tests_changed) else 0
+    factors["no_tests"] = {
+        "points": pts,
+        "detail": ("source changed with no test changes"
+                   if pts else "tests touched or no source changes")}
+
+    # Deletions: pure-deletion PRs contribute ~0 to agent_share (no added
+    # lines), so a deletion factor makes sure they can still trip the
+    # threshold. Only agent-attributed deletions count — a human deleting
+    # a file is their own review problem, not an agent-trust problem.
+    # Deleting sensitive code is the worst case (45): unlike a touch, the
+    # file can no longer be fixed in place, only restored. Otherwise an
+    # agent deleting tracked files at all is worth 10, plus
+    # blast-radius-style points for the deleted files' dependents (a
+    # deleted import breaks its importers just like a bad edit would).
+    agent_deleted = [f for f in prov.values()
+                     if f.deleted and f.agents]
+    if agent_deleted:
+        del_names = [f.file for f in agent_deleted]
+        max_dep = max((blast[f].size for f in del_names if f in blast),
+                      default=0)
+        pts = _blast_points(max_dep, 25)
+        if _sensitive_hits(del_names, sensitive_paths):
+            pts += 45
+        else:
+            pts += 10
+        pts = min(50, pts)
+        factors["deletion"] = {
+            "points": pts,
+            "detail": (f"agent-deleted: {', '.join(del_names)}; "
+                       f"sensitive: "
+                       f"{', '.join(_sensitive_hits(del_names, sensitive_paths)) or 'none'}; "
+                       f"largest deleted-file dependents: {max_dep}")}
+    else:
+        factors["deletion"] = {
+            "points": 0,
+            "detail": "no agent-attributed deletions"}
+
+    total = min(100, sum(f["points"] for f in factors.values()))
+    band = "low" if total < 30 else "medium" if total < 70 else "high"
+    return RiskBreakdown(score=total, band=band, factors=factors,
+                         requires_review=total >= threshold)

pr_verify-0.1.0.dist-info/METADATA

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: pr-verify
+Version: 0.1.0
+Summary: Deterministic trust scoring for agent-authored PRs.
+Author: Calas Automations Inc.
+License: MIT
+Project-URL: Homepage, https://github.com/calasdan-sketch/pr-verify
+Project-URL: Issues, https://github.com/calasdan-sketch/pr-verify/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# PR Verify
+
+Deterministic trust for agent-authored PRs. Not another AI reviewer —
+**verification, not opinion.** Agents now write more code than seniors can
+review; this tells a senior exactly how deep to review, from observable
+facts: which lines an agent wrote, what could break, and whether policy
+gates pass.
+
+## Install
+
+```bash
+git clone <repo> && cd pr-verify
+pip install .   # provides the `pr-verify` console script
+```
+
+Or run without installing: `python3 -m pr_verify` from the repo root.
+
+## Quick start
+
+```bash
+cd your-repo
+python3 -m pr_verify init        # write an example .pr-verify.yaml
+python3 -m pr_verify check --base main
+```
+
+## What it reports
+
+**Provenance** — every added line labeled agent/human via `git blame` +
+commit-author analysis (configurable markers: claude, codex, cursor,
+copilot, bot…). Per file: `agent` / `mixed` / `human`, with the detected
+agent identities.
+
+**Blast radius** — reverse dependency graph: for each changed file, the
+transitive set of in-repo dependents that could break. Python via AST;
+JS/TS/Go/Rust/Java/Ruby/PHP via heuristic fallback.
+
+**Policy gates** — commands from `.pr-verify.yaml` (tests, typecheck,
+lint), run with timeout, pass/fail captured. The config is read from the
+base ref (never the worktree under review) and gates run **without** a
+shell — `;`, `&&`, `$()`, pipes and the rest are literal arguments, never
+interpreted. A failing gate fails the verification (nonzero exit).
+
+**Risk score** — deterministic 0–100 from six public factors:
+
+| Factor | Max | What it measures |
+|---|---|---|
+| agent_share | 40 | % of added lines agent-authored |
+| blast | 25 | log-scaled transitive dependents |
+| sensitive | 20 | changed files under sensitive globs (auth, crypto, payments, migrations…); deleted files match like touched ones |
+| gates | 10 | any policy gate failed |
+| no_tests | 5 | source changed with no test changes |
+| deletion | 50 | agent-attributed deletions: 45 if any deleted file is sensitive, else 10 for deleting tracked files at all, plus log-scaled points for the deleted files' dependents — pure-deletion PRs can trip the threshold too |
+
+Bands: 0–29 low · 30–69 medium · 70–100 high. The formula is documented so
+teams can argue with it and tune it — a black-box score is just another
+opinion.
+
+## CI
+
+```bash
+python3 -m pr_verify check --base origin/main --format json --fail-on high
+```
+
+`--fail-on high` (default) exits 1 when score ≥ `risk_threshold` (70).
+`--fail-on any-risk` / `--fail-on never` available. A GitHub Action is
+included at `.github/workflows/pr-verify.yml`.
+
+## Example output
+
+```
+════════════════════════════════════════════════════════
+  PR VERIFY  risk 57/100 (MEDIUM)
+════════════════════════════════════════════════════════
+
+  provenance: 9/13 added lines agent-authored
+    agent   app/auth.py (4/4 agent) [claude-bot]
+    mixed   app/core.py (4/8 agent) [claude-bot]
+    agent   app/views.py (1/1 agent) [claude-bot]
+
+  blast radius:
+    app/core.py: 1 downstream dependent(s)
+      direct: app/views.py
+
+  risk factors:
+     28 pts  agent_share  9/13 added lines agent-authored (69%)
+      4 pts  blast        largest blast radius: 1 downstream dependent(s)
+     20 pts  sensitive    sensitive files touched: app/auth.py
+      0 pts  gates        no gates configured
+      5 pts  no_tests     source changed with no test changes
+
+  ✓ score 57 < threshold 70
+════════════════════════════════════════════════════════
+```
+
+## Honest limits
+
+- Provenance depends on commit authorship — squashed or rebased PRs lose
+  per-commit attribution (tune `agent_markers` for your workflow).
+  Uncommitted working-tree changes are included in `check`, but with no
+  commit to blame they are counted as human-written, never agent-written.
+- Non-Python blast-radius extraction is heuristic.
+- The risk formula is a starting point, not a verdict — tune the threshold
+  per team.
+
+## Tests
+
+55/55 pass: `python3 -m unittest discover -s tests`

pr_verify-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+pr_verify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pr_verify/__main__.py,sha256=MHKZ_ae3fSLGTLUUMOx15fWdeOnJSHhq-zslRP5F5Lc,79
+pr_verify/blastradius.py,sha256=xfl8mbqeHzYs-bnMuJ2Llgy5llMYMHx5wNK_VA01VAU,6413
+pr_verify/cli.py,sha256=F7L6DIOCvkIxnb7zboEgK6qXY7L9kPQ9LDPYfgvNog4,6693
+pr_verify/config.py,sha256=6mT4lBBtg5F8N9MZUT4_bWjzGVxNuhHUqm_aPO5PuhA,2617
+pr_verify/gates.py,sha256=P_mDVGt-3Rq-ZwoFsAZHS9leN2iCq-uiLM72jAUBQ50,2239
+pr_verify/miniyaml.py,sha256=bDpXNkei59wFIOd3Jf7Z_gqVXHI1RpqtUxpRT3a1yCU,9170
+pr_verify/provenance.py,sha256=A8ltrU3I9JDWczhhzPAXw5TXfDR5kY4guqi9Io769qI,8523
+pr_verify/risk.py,sha256=BL2k-OiyPtUNOp511YG2cs28LavLWuHKiYM9mY4zvoY,6653
+pr_verify-0.1.0.dist-info/licenses/LICENSE,sha256=f-qFLkEfvZidBgKv2YINOOKS7Trk_gj1c6Cy718D8F0,1079
+pr_verify-0.1.0.dist-info/METADATA,sha256=5NWE48uF6pBzDDqKesQqG6P6zp6zTO_PWjbJeq6PKj4,4735
+pr_verify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+pr_verify-0.1.0.dist-info/entry_points.txt,sha256=BpWIv-124hHwJfd4L0KyzfN77DzvpcQEs9TvNGY5qIs,49
+pr_verify-0.1.0.dist-info/top_level.txt,sha256=N78V88hw0XwT2_QsRW-woqa9APQ95XoNjfwQctre4vc,10
+pr_verify-0.1.0.dist-info/RECORD,,

pr_verify-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
+

pr_verify-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pr-verify = pr_verify.cli:main

pr_verify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Calas Automations Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pr_verify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pr_verify