code-jig 0.12.0__py3-none-any.whl

codejig/gitgate.py

@@ -0,0 +1,278 @@
+import os
+import re
+import shlex
+import subprocess
+import sys
+from pathlib import Path
+
+from codejig.scrub import (
+    Abort,
+    blocker,
+    common_dir,
+    my_emails,
+    range_revs,
+    rewrite_range,
+)
+from codejig.watermark import clean_message, has_watermark, is_binary, strip_bytes
+
+ZERO = "0" * 40
+AGENT_ENV = ("CODEX_THREAD_ID", "CLAUDECODE")
+DASHES = {"\u2014": "-", "\u2013": "-", "\u2015": "-"}
+PROSE = re.compile(r"(?i)(?:^|/)(?:readme|changelog|changes|history|contributing)(?:\.[^/]*)?$|\.(?:md|mdx|markdown|rst|adoc)$")
+NOT_PROSE = re.compile(r"(?:^|/)(?:AGENTS(?:\.override)?\.md|CLAUDE\.md|SKILL\.md)$|(?:^|/)specs?/")
+VENDORED = re.compile(r"(?:^|/)(?:node_modules|vendor|dist|\.obsidian)/|\.min\.(?:js|css)$")
+HOOK_GIT_ENV = ("GIT_DIR", "GIT_WORK_TREE", "GIT_INDEX_FILE", "GIT_COMMON_DIR", "GIT_PREFIX",
+                "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES")
+GATED = ("commit-msg", "pre-commit", "pre-push")
+HOOKS = ("applypatch-msg", "pre-applypatch", "post-applypatch", "pre-commit", "pre-merge-commit",
+         "prepare-commit-msg", "commit-msg", "post-commit", "pre-rebase", "post-checkout", "post-merge",
+         "pre-push", "pre-receive", "update", "post-receive", "post-update", "push-to-checkout",
+         "pre-auto-gc", "post-rewrite", "sendemail-validate")
+
+
+def _git(*args: str, stdin: bytes | None = None, check: bool = True) -> bytes:
+    r = subprocess.run(["git", *args], capture_output=True, input=stdin, check=False)
+    if check and r.returncode:
+        raise RuntimeError(f"git {' '.join(args)}: {r.stderr.decode('utf-8', 'replace').strip()}")
+    return r.stdout
+
+
+def undash(data: bytes) -> bytes:
+    text = data.decode("utf-8")
+    for dash, plain in DASHES.items():
+        text = text.replace(dash, plain)
+    return text.encode("utf-8")
+
+
+def commit_msg(path: str) -> int:
+    p = Path(path)
+    data = p.read_bytes()
+    try:
+        new = undash(clean_message(data))
+    except UnicodeDecodeError:
+        return 0
+    if new != data:
+        p.write_bytes(new)
+        print("code-jig: cleaned the commit message (AI attribution, dashes)", file=sys.stderr)
+    return 0
+
+
+def is_prose(path: str) -> bool:
+    return bool(PROSE.search(path)) and not NOT_PROSE.search(path)
+
+
+def _fix(data: bytes, path: str) -> bytes | None:
+    if data.isascii() or b"\0" in data[:8192] or is_binary(data):
+        return None
+    cleaned, _ = strip_bytes(data, attribution=False)
+    if is_prose(path):
+        cleaned = undash(cleaned)
+    return cleaned if cleaned != data else None
+
+
+def _from_agent() -> bool:
+    return any(os.environ.get(k) for k in AGENT_ENV)
+
+
+def _prose_allowed() -> bool:
+    return _git("config", "--local", "--bool", "codejig.allowProse", check=False).strip() == b"true"
+
+
+def _fix_staged(path: str, mode: str, sha: str) -> bool:
+    new = _fix(_git("cat-file", "blob", sha), path)
+    if new is not None:
+        blob = _git("hash-object", "-w", "--no-filters", "--stdin", stdin=new).decode().strip()
+        _git("update-index", "--cacheinfo", f"{mode},{blob},{path}")
+    work = Path(path)
+    if work.is_file() and not work.is_symlink():
+        fixed = _fix(work.read_bytes(), path)
+        if fixed is not None:
+            work.write_bytes(fixed)
+    return new is not None
+
+
+def _staged() -> list[tuple[str, str, str]]:
+    """(path, mode, blob) of every added or modified regular file, renames counted as additions.
+
+    Read from one raw diff, so a file name is never interpreted as a pathspec."""
+    fields = _git("diff", "--cached", "--raw", "-z", "--no-renames", "--no-abbrev", "--diff-filter=AM").split(b"\0")
+    out = []
+    for meta, path in zip(fields[0::2], fields[1::2], strict=False):
+        parts = meta.decode().lstrip(":").split()
+        if len(parts) == 5 and parts[1] in ("100644", "100755"):
+            out.append((os.fsdecode(path), parts[1], parts[3]))
+    return out
+
+
+def pre_commit(prose: bool) -> int:
+    staged = _staged()
+    prose_files = [path for path, _, _ in staged if is_prose(path)]
+    fixed = [path for path, mode, sha in staged if not VENDORED.search(path) and _fix_staged(path, mode, sha)]
+    if fixed:
+        print(f"code-jig: replaced invisible characters in {', '.join(fixed)}", file=sys.stderr)
+    if prose and prose_files and _from_agent() and not _prose_allowed():
+        print("code-jig: refusing to commit prose written in an agent session:", file=sys.stderr)
+        for path in prose_files:
+            print(f"  {path}", file=sys.stderr)
+        print("Unstage these files (git restore --staged <file>) and commit the rest; the user reviews and commits "
+              "the prose. A repo where agents may commit prose: git config codejig.allowProse true",
+              file=sys.stderr)
+        return 1
+    return 0
+
+
+def _known(remote: str) -> bool:
+    return remote != ZERO and subprocess.run(["git", "cat-file", "-e", f"{remote}^{{commit}}"], capture_output=True, check=False).returncode == 0
+
+
+def _outgoing(local: str, remote: str) -> list[str]:
+    spec = [f"{remote}..{local}"] if _known(remote) else [local, "--not", "--remotes"]
+    return _git("rev-list", "--no-merges", *spec).decode().split()
+
+
+def _cleanup_on(default: bool) -> bool:
+    value = _git("config", "--bool", "--get", "codejig.pushCleanup", check=False).strip()
+    return {b"true": True, b"false": False}.get(value, default)
+
+
+def _base(remote: str) -> str | None:
+    return remote if _known(remote) else None
+
+
+def _read(path: Path) -> str:
+    return path.read_text(encoding="utf-8", errors="replace") if path.is_file() else ""
+
+
+def _rebasing(ref: str) -> bool:
+    common = common_dir(Path.cwd())
+    for gitdir in [common, *common.glob("worktrees/*")]:
+        merge, apply = gitdir / "rebase-merge", gitdir / "rebase-apply"
+        busy = [_read(merge / "head-name"), _read(apply / "head-name"), *_read(merge / "update-refs").splitlines()]
+        if (apply / "applying").exists():
+            busy.append(_read(gitdir / "HEAD").strip().removeprefix("ref: "))
+        if ref in (b.strip() for b in busy):
+            return True
+    return False
+
+
+def _cleanable(ref: str, local: str, remote: str, bad: list[str], emails: set[str]) -> bool:
+    if not ref.startswith("refs/heads/") or _git("rev-parse", "-q", "--verify", ref, check=False).decode().strip() != local:
+        return False
+    if _rebasing(ref) or not set(bad) <= set(_git("rev-list", *bad, "--not", "--remotes").decode().split()):
+        return False
+    return blocker(Path.cwd(), range_revs(ref, _base(remote)), emails) is None
+
+
+def _clean(branches: dict[str, tuple[str, str, list[str]]], emails: set[str]) -> bool:
+    done, notes = {}, []
+    try:
+        for ref, (local, remote, _) in branches.items():
+            done[ref] = local
+            n, bundle = rewrite_range(Path.cwd(), ref, _base(remote), emails)
+            notes.append(f"code-jig: cleaned AI attribution from {n} commits on {ref.removeprefix('refs/heads/')}; "
+                         f"backup {bundle}; run the same push again")
+    except Abort as e:
+        for ref, old in done.items():
+            _git("update-ref", ref, old)
+        print(f"code-jig: cleanup aborted, nothing changed: {e}", file=sys.stderr)
+        return False
+    print("\n".join(notes), file=sys.stderr)
+    return True
+
+
+def _bad_commits(local: str, remote: str, emails: set[str]) -> list[str]:
+    bad = []
+    for sha in _outgoing(local, remote):
+        email, _, body = _git("log", "-1", "--format=%ae%x00%B", sha).partition(b"\0")
+        if email.decode("utf-8", "replace").lower() in emails and has_watermark(body):
+            bad.append(sha)
+    return bad
+
+
+def _push_ref(ref: str) -> str:
+    if ref == "HEAD":
+        return _git("symbolic-ref", "-q", "HEAD", check=False).decode().strip() or ref
+    return ref
+
+
+def _collect_problems(lines: list[str], emails: set[str]) -> tuple[list[str], dict]:
+    problems, branches = [], {}
+    for parts in (line.split() for line in lines):
+        if len(parts) != 4 or parts[1] == ZERO:
+            continue
+        bad = _bad_commits(parts[1], parts[3], emails)
+        if bad:
+            problems += bad
+            branches[_push_ref(parts[0])] = (parts[1], parts[3], bad)
+    return problems, branches
+
+
+def _refuse(problems: list[str]) -> int:
+    print("code-jig: push refused, commit messages carry AI attribution:", file=sys.stderr)
+    for sha in dict.fromkeys(problems):
+        print(f"  {sha[:10]} {_git('log', '-1', '--format=%s', sha).decode().strip()}", file=sys.stderr)
+    print("Remove it with: code-jig scrub (rewrites messages only, then prints the push commands)", file=sys.stderr)
+    return 1
+
+
+def pre_push(lines: list[str], cleanup: bool = False) -> int:
+    emails = my_emails(Path.cwd())
+    problems, branches = _collect_problems(lines, emails)
+    if not problems:
+        return _run_tests()
+    if _cleanup_on(cleanup) and all(_cleanable(ref, local, remote, bad, emails)
+                                    for ref, (local, remote, bad) in branches.items()) and _clean(branches, emails):
+        return 1
+    return _refuse(problems)
+
+
+def _run_tests() -> int:
+    cmd = _git("config", "--get", "codejig.testCommand", check=False).decode("utf-8", "replace").strip()
+    if not cmd:
+        return 0
+    if os.environ.get("CODE_JIG_SKIP_TESTS") == "1":
+        print("code-jig: CODE_JIG_SKIP_TESTS=1, skipping the pre-push tests", file=sys.stderr)
+        return 0
+    try:
+        top = _git("rev-parse", "--show-toplevel").decode("utf-8", "replace").strip()
+    except RuntimeError:
+        top = ""
+    if not top:
+        print("code-jig: push refused, cannot find the repo top level to run tests", file=sys.stderr)
+        return 1
+    env = {k: v for k, v in os.environ.items() if k not in HOOK_GIT_ENV}
+    rc = subprocess.run(cmd, shell=True, cwd=top, env=env, check=False).returncode
+    if rc:
+        print(f"code-jig: push refused, tests fail ({cmd} exited {rc})", file=sys.stderr)
+        return 1
+    return 0
+
+
+def shims(lib: Path, python: str, prose: bool, cleanup: bool = False) -> dict[str, str]:
+    """One POSIX shell hook per git hook name: the gate for the gated ones, then the repo's own hook."""
+    run = f"PYTHONPATH={shlex.quote(Path(lib).as_posix())} {shlex.quote(Path(python).as_posix())} -P -s -m codejig git-hook"
+    local = 'dir="$(git rev-parse --git-common-dir 2>/dev/null)/hooks"'
+    out = {}
+    for name in HOOKS:
+        if name == "pre-push":
+            body = (f'input=$(cat)\nprintf \'%s\\n\' "$input" | {run}{" --cleanup" if cleanup else ""} pre-push "$@" || exit 1\n{local}\n'
+                    f'[ -x "$dir/{name}" ] && {{ printf \'%s\\n\' "$input" | "$dir/{name}" "$@"; exit $?; }}\nexit 0\n')
+        else:
+            flag = " --prose" if name == "pre-commit" and prose else ""
+            gate = f'{run}{flag} {name} "$@" || exit 1\n' if name in GATED else ""
+            body = f'{gate}{local}\n[ -x "$dir/{name}" ] && exec "$dir/{name}" "$@"\nexit 0\n'
+        out[name] = "#!/bin/sh\n" + body
+    return out
+
+
+def cli(args) -> int:
+    try:
+        if args.name == "commit-msg" and args.rest:
+            return commit_msg(args.rest[0])
+        if args.name == "pre-commit":
+            return pre_commit(args.prose)
+        if args.name == "pre-push":
+            return pre_push(sys.stdin.read().splitlines(), args.cleanup)
+    except (OSError, RuntimeError) as e:
+        print(f"code-jig: git hook {args.name} skipped: {e}", file=sys.stderr)
+    return 0

codejig/hooks.py

@@ -0,0 +1,64 @@
+import json
+import re
+import sys
+
+from codejig.feedback import lint, patch_bodies, tamper
+from codejig.humanize import humanize_file
+from codejig.humanize import report_result as report_humanize
+from codejig.watermark import report_result as report_watermark
+from codejig.watermark import strip_watermark
+
+PATCH_PATH = re.compile(r"^\*\*\* (?:Add File|Update File|Move to): (.+?)\s*$", re.MULTILINE)
+CLAUDE_WRITE_TOOLS = {"Write", "Edit", "MultiEdit", "NotebookEdit"}
+
+
+def changed_paths(tool_name: object, tool_input: object) -> list[str]:
+    """Files this tool call wrote, and nothing else.
+
+    Claude Code's write tools name their file; Codex's apply_patch names its
+    targets inside the patch argument. Every other tool, including ones that
+    merely read a `path`, gives an empty list.
+    """
+    if tool_name in CLAUDE_WRITE_TOOLS and isinstance(tool_input, dict):
+        path = tool_input.get("file_path") or tool_input.get("notebook_path")
+        return [path] if isinstance(path, str) else []
+    if tool_name == "apply_patch":
+        found = [p for body in patch_bodies(tool_input) for p in PATCH_PATH.findall(body)]
+        return list(dict.fromkeys(found))
+    return []
+
+
+def clean(paths: list[str], root: str | None) -> list[str]:
+    notes = []
+    for path in paths:
+        for note in (
+            report_watermark(strip_watermark(path, root)),
+            report_humanize(humanize_file(path, root)),
+        ):
+            if note:
+                notes.append(note)
+    return notes
+
+
+def handle_posttooluse() -> int:
+    """PostToolUse for Claude Code and Codex: clean what the tool wrote, then say what changed."""
+    try:
+        payload = json.loads(sys.stdin.read() or "{}")
+        name, tool_input, cwd = payload.get("tool_name"), payload.get("tool_input"), payload.get("cwd")
+        written = changed_paths(name, tool_input)
+        notes = clean(written, cwd)
+        notes += [n for n in (lint(p, cwd) for p in written) if n]
+        notes += tamper(name, tool_input)
+        if notes:
+            msg = "; ".join(notes)
+            sys.stdout.write(json.dumps({
+                "systemMessage": msg,
+                "hookSpecificOutput": {"hookEventName": "PostToolUse", "additionalContext": msg},
+            }) + "\n")
+    except Exception as e:
+        print(f"watermark: hook error: {e}", file=sys.stderr)
+    return 0
+
+
+def cli(args) -> int:
+    return handle_posttooluse()

codejig/humanize.py

@@ -0,0 +1,206 @@
+import io
+import os
+import re
+import sys
+import tokenize
+from pathlib import Path
+
+from codejig.atomicwrite import atomic_write, resolve_inside
+
+DASHES = str.maketrans({"—": "-", "–": "-", "―": "-"})
+CURLY_QUOTES = str.maketrans({
+    "‘": "'", "’": "'",
+    "“": '"', "”": '"',
+})
+ELLIPSIS = "…"
+
+LLM_BOILERPLATE = [
+    "Here's the updated",
+    "Here is the updated",
+    "I hope this helps",
+    "Let me know if",
+    "Feel free to",
+    "As an AI",
+    "As an assistant",
+    "Add more as needed",
+    "Rest of the code",
+    "... existing code ...",
+    "... your code ...",
+    "Your code here",
+]
+
+BOILERPLATE_PATTERN = re.compile(
+    r"(?:certainly[!.,]?\s*$|(?:" + "|".join(re.escape(p) for p in LLM_BOILERPLATE) + r")(?![\w']))",
+    re.IGNORECASE,
+)
+
+COMMENT_MARKERS = {
+    ".py": "#",
+    ".js": ("//", "/*"),
+    ".ts": ("//", "/*"),
+    ".tsx": ("//", "/*"),
+    ".jsx": ("//", "/*"),
+    ".mjs": ("//", "/*"),
+    ".sh": "#",
+    ".bash": "#",
+    ".css": "/*",
+    ".go": "//",
+    ".rs": ("//", "/*"),
+    ".java": ("//", "/*"),
+    ".c": ("//", "/*"),
+    ".cpp": ("//", "/*"),
+    ".cc": ("//", "/*"),
+    ".cs": ("//", "/*"),
+    ".rb": "#",
+    ".yaml": "#",
+    ".yml": "#",
+    ".toml": "#",
+}
+
+EMOJI_PATTERN = re.compile(
+    r"[\U0001F300-\U0001F9FF]|[☀-➿]|[\U0001F600-\U0001F64F]|[\U0001F900-\U0001F9FF]",
+    flags=re.UNICODE
+)
+
+
+def get_file_extension(path: str) -> str:
+    p = Path(path)
+    return p.suffix.lower()
+
+
+def is_comment_line(line: str, markers) -> bool:
+    stripped = line.lstrip()
+    if isinstance(markers, str):
+        return stripped.startswith(markers)
+    if isinstance(markers, tuple):
+        return any(stripped.startswith(m) for m in markers)
+    return False
+
+
+def is_boilerplate_line(line: str, markers=None) -> bool:
+    stripped = line.strip()
+    if not stripped:
+        return False
+
+    comment_text = stripped
+    if markers:
+        if isinstance(markers, str):
+            if comment_text.startswith(markers):
+                comment_text = comment_text[len(markers):].lstrip()
+        elif isinstance(markers, tuple):
+            for m in markers:
+                if comment_text.startswith(m):
+                    comment_text = comment_text[len(m):].lstrip()
+                    break
+
+    return BOILERPLATE_PATTERN.match(comment_text) is not None
+
+
+def python_comment_lines(text: str) -> set[int] | None:
+    """0-based numbers of lines that hold only a comment, read by the tokenizer so
+    a `#` inside a string literal is never mistaken for one. None if it cannot parse."""
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(text).readline))
+    except (tokenize.TokenError, SyntaxError):
+        return None
+    lines = text.split("\n")
+    return {
+        t.start[0] - 1
+        for t in tokens
+        if t.type == tokenize.COMMENT and not lines[t.start[0] - 1][: t.start[1]].strip()
+    }
+
+
+def humanize_text(text: str, markers, comment_lines: set[int] | None = None) -> tuple[str, dict]:
+    counts = {"dashes": 0, "quotes": 0, "ellipsis": 0, "emoji": 0, "boilerplate": 0}
+    kept = []
+    for number, line in enumerate(text.split("\n")):
+        is_comment = number in comment_lines if comment_lines is not None else is_comment_line(line, markers)
+        if not is_comment:
+            kept.append(line)
+            continue
+        if is_boilerplate_line(line, markers):
+            counts["boilerplate"] += 1
+            continue
+        counts["dashes"] += sum(line.count(d) for d in "—–―")
+        counts["quotes"] += sum(1 for c in line if c in "‘’“”")
+        counts["ellipsis"] += line.count(ELLIPSIS)
+        counts["emoji"] += len(EMOJI_PATTERN.findall(line))
+        line = EMOJI_PATTERN.sub("", line.translate(DASHES).translate(CURLY_QUOTES).replace(ELLIPSIS, "..."))
+        kept.append(line)
+    return "\n".join(kept), counts
+
+
+def humanize_file(path: str, root: str | None = None, write: bool = True) -> dict:
+    result = {"file": path, "dashes": 0, "quotes": 0, "ellipsis": 0, "emoji": 0, "boilerplate": 0}
+    markers = COMMENT_MARKERS.get(get_file_extension(path))
+    target = resolve_inside(path, root)
+    if markers is None or target is None:
+        return result
+    try:
+        original = target.read_bytes()
+        if b"\0" in original[:8192]:
+            return result
+        text = original.decode("utf-8")
+        comment_lines = None
+        if target.suffix.lower() == ".py":
+            comment_lines = python_comment_lines(text)
+            if comment_lines is None:
+                return result
+        new_text, counts = humanize_text(text, markers, comment_lines)
+        result.update(counts)
+        if new_text != text:
+            result["changed"] = True
+            if write:
+                atomic_write(target, new_text.encode("utf-8"))
+    except UnicodeDecodeError:
+        return result
+    except Exception as e:
+        print(f"humanize: error processing {path}: {e}", file=sys.stderr)
+    return result
+
+
+def report_result(result: dict) -> str | None:
+    if not result.get("changed"):
+        return None
+    parts = []
+    if result.get("boilerplate"):
+        parts.append(f"{result['boilerplate']} boilerplate")
+    if result.get("dashes"):
+        parts.append(f"{result['dashes']} dashes")
+    if result.get("quotes"):
+        parts.append(f"{result['quotes']} quotes")
+    if result.get("ellipsis"):
+        parts.append(f"{result['ellipsis']} ellipsis")
+    if result.get("emoji"):
+        parts.append(f"{result['emoji']} emoji")
+
+    msg = f"humanize: {result['file']}: fixed {', '.join(parts)}"
+    print(msg, file=sys.stderr)
+    return msg
+
+
+SKIP_DIRS = {".git", "node_modules", ".venv", "venv", "__pycache__", "dist", "build"}
+
+
+def _files(root: Path):
+    if root.is_file():
+        yield root
+        return
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS and not d.startswith(".")]
+        for name in filenames:
+            yield Path(dirpath) / name
+
+
+def cli(args) -> int:
+    changed = 0
+    for path_str in args.path or []:
+        start = Path(path_str).resolve()
+        root = start if start.is_dir() else start.parent
+        for f in _files(start):
+            result = humanize_file(str(f), root=str(root), write=not args.check)
+            if result.get("changed"):
+                changed += 1
+                report_result(result)
+    return 1 if args.check and changed else 0