git-deai 0.1.0__py3-none-any.whl

deai/__init__.py

@@ -0,0 +1 @@
+"""deai: find and remove AI co-author credits from git history."""

deai/cli.py

@@ -0,0 +1,337 @@
+"""deai: find and remove AI co-author credits from git history.
+
+AI coding tools append trailers such as ``Co-Authored-By: Claude <noreply@anthropic.com>``
+to commit messages. GitHub reads those trailers and lists the tool as a contributor.
+deai finds them, and on request rewrites the history without them.
+
+    deai scan [PATH ...] [-r]       report, change nothing
+    deai clean [PATH ...] [-r] [--yes] [--push]
+
+What ``clean`` removes from every commit message:
+- ``Co-authored-by:`` trailers whose name or e-mail matches a known AI tool;
+- "Generated with <AI tool>" lines (e.g. "🤖 Generated with [Claude Code](...)").
+Human co-authors stay. Commits *authored* or *committed* by an AI identity are re-attributed
+to the repository's ``git config user.name / user.email`` (or ``--as``).
+
+Safety:
+- the worktree must have no uncommitted changes to tracked files;
+- a full backup bundle is written to ``.git/deai-backup-<time>.bundle`` first;
+- only local branches and tags are rewritten. Remote-tracking refs keep the old history,
+  so ``--push`` can use ``--force-with-lease`` against what the remote really has;
+- nothing is pushed unless ``--push`` is given.
+
+Rewriting changes every commit hash from the first cleaned commit on. Anyone else with a
+clone must re-clone or rebase afterwards.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+
+AI = re.compile(
+    r"claude|anthropic|copilot|cursor(agent)?\b|chatgpt|openai|\bcodex\b|gemini|\bdevin\b|"
+    r"\baider\b|codeium|windsurf|tabnine|codewhisperer|amazon q\b|\bjules\b|sweep-?ai",
+    re.IGNORECASE,
+)
+COAUTHOR = re.compile(r"^[ \t]*co-authored-by:[ \t]*(?P<who>.*)$", re.IGNORECASE)
+GENERATED = re.compile(r"^.*\bgenerated (with|by)\b(?P<who>.*)$", re.IGNORECASE)
+IDENT = re.compile(rb"^(?P<kind>author|committer) (?P<name>.*?) <(?P<email>[^>]*)> (?P<when>.*)$")
+SKIP_DIRS = {".git", "node_modules", ".venv", "venv", "__pycache__", ".tox", "dist", "build"}
+
+
+def is_ai(text: str) -> bool:
+    return bool(AI.search(text))
+
+
+def clean_message(msg: str) -> str:
+    """Drop AI co-author trailers and "generated with <AI>" lines; keep everything else."""
+    kept = []
+    for line in msg.splitlines():
+        m = COAUTHOR.match(line) or GENERATED.match(line)
+        if m and is_ai(m["who"]):
+            continue
+        kept.append(line)
+    while kept and not kept[-1].strip():          # the trailer block often leaves a blank tail
+        kept.pop()
+    return "\n".join(kept) + ("\n" if msg.endswith("\n") or kept else "")
+
+
+# ───────────── git plumbing ─────────────
+
+def git(repo: Path, *args: str, check: bool = True) -> str:
+    r = subprocess.run(["git", "-C", str(repo), *args], capture_output=True, text=True,
+                       encoding="utf-8", errors="replace")
+    if check and r.returncode:
+        raise RuntimeError(f"git {' '.join(args)} failed in {repo}:\n{r.stderr.strip()}")
+    return r.stdout
+
+
+def find_repos(paths: list[str], recursive: bool) -> list[Path]:
+    out = []
+    for p in map(Path, paths or ["."]):
+        p = p.resolve()
+        if (p / ".git").exists():
+            out.append(p)
+            continue
+        if not recursive:
+            print(f"skip {p}: not a git repository (use -r to search below it)", file=sys.stderr)
+            continue
+        for root, dirs, _ in os.walk(p):
+            if ".git" in dirs or (Path(root) / ".git").is_file():
+                out.append(Path(root))
+                dirs[:] = []                       # do not descend into a repository
+                continue
+            dirs[:] = [d for d in dirs if d not in SKIP_DIRS and not d.startswith(".")]
+    return sorted(set(out))
+
+
+@dataclass
+class Report:
+    repo: Path
+    commits: int = 0
+    trailers: list[str] = field(default_factory=list)   # short hashes with an AI trailer/line
+    idents: list[str] = field(default_factory=list)     # short hashes with an AI author/committer
+    others: set[str] = field(default_factory=set)       # human authors of flagged commits who are not you
+
+    @property
+    def dirty(self) -> bool:
+        return bool(self.trailers or self.idents)
+
+
+def my_emails(repo: Path, extra: list[str]) -> set[str]:
+    me = git(repo, "config", "user.email", check=False).strip()
+    return {e.lower() for e in [me, *extra] if e}
+
+
+def scan(repo: Path, me: list[str] | None = None) -> Report:
+    """Flag commits with AI credits. A flagged commit by another human means shared history
+    (a fork, a vendored project): rewriting it would split you from upstream."""
+    r = Report(repo)
+    if not git(repo, "rev-parse", "--verify", "-q", "HEAD", check=False).strip():
+        return r                                   # empty repository
+    mine = my_emails(repo, me or [])
+    log = git(repo, "log", "--branches", "--tags", "--format=%h%x00%an <%ae>%x00%ae%x00%cn <%ce>%x00%B%x1e")
+    for rec in filter(str.strip, log.split("\x1e")):
+        h, author, email, committer, body = rec.strip("\n").split("\x00", 4)
+        r.commits += 1
+        flagged = False
+        if clean_message(body) != clean_message_noop(body):
+            r.trailers.append(h)
+            flagged = True
+        if is_ai(author) or is_ai(committer):
+            r.idents.append(h)
+            flagged = True
+        if flagged and not is_ai(author) and email.lower() not in mine:
+            r.others.add(author)
+    return r
+
+
+def clean_message_noop(msg: str) -> str:
+    """The same normalisation as clean_message without removing anything (fair comparison)."""
+    kept = msg.splitlines()
+    while kept and not kept[-1].strip():
+        kept.pop()
+    return "\n".join(kept) + ("\n" if msg.endswith("\n") or kept else "")
+
+
+# ───────────── rewrite ─────────────
+
+def rewrite_stream(src, dst, ident: bytes) -> int:
+    """Copy a ``git fast-export`` stream, cleaning commit messages and AI identities.
+
+    Returns the number of commits changed. Blob and tag payloads pass through untouched;
+    only the first ``data`` block after a ``commit`` command is a commit message.
+    """
+    changed, in_commit, msg_next, touched = 0, False, False, False
+    while line := src.readline():
+        if line.startswith(b"commit "):
+            in_commit, msg_next, touched = True, True, False
+        elif line.startswith((b"blob", b"tag ", b"reset ")):
+            in_commit, msg_next = False, False
+        elif in_commit and (m := IDENT.match(line.rstrip(b"\n"))):
+            who = (m["name"] + b" <" + m["email"] + b">").decode("utf-8", "surrogateescape")
+            if is_ai(who):
+                line = m["kind"] + b" " + ident + b" " + m["when"] + b"\n"
+                touched = True
+        elif line.startswith(b"data "):
+            payload = src.read(int(line[5:]))
+            if msg_next:
+                msg_next = False
+                text = payload.decode("utf-8", "surrogateescape")
+                new = clean_message(text)
+                if new != clean_message_noop(text):
+                    payload, touched = new.encode("utf-8", "surrogateescape"), True
+                changed += touched
+            dst.write(b"data %d\n" % len(payload) + payload)
+            continue
+        dst.write(line)
+    return changed
+
+
+@dataclass
+class Tracked:
+    branch: str        # local branch name
+    remote: str        # e.g. origin
+    remote_ref: str    # e.g. refs/heads/main on the remote
+    upstream: str      # e.g. refs/remotes/origin/main
+    oid: str = ""      # upstream commit at fetch time: the lease for the force-push
+
+
+def tracked_branches(repo: Path) -> list[Tracked]:
+    fmt = "%(refname:short)%00%(upstream:remotename)%00%(upstream:remoteref)%00%(upstream)"
+    out = []
+    for line in git(repo, "for-each-ref", f"--format={fmt}", "refs/heads").splitlines():
+        b, remote, rref, up = line.split("\x00")
+        oid = git(repo, "rev-parse", "-q", "--verify", up, check=False).strip() if up else ""
+        if remote and oid:                         # upstream configured and present after fetch
+            out.append(Tracked(b, remote, rref, up, oid))
+    return out
+
+
+def sync_with_remote(repo: Path) -> list[Tracked]:
+    """Fetch, and make sure no local branch is behind its upstream before rewriting.
+
+    A force-push of a branch that is *behind* the remote would throw the remote's newer
+    commits away, so a branch that is strictly behind is fast-forwarded first, and a branch
+    that has diverged stops the run.
+    """
+    git(repo, "fetch", "--all", "--quiet")
+    current = git(repo, "branch", "--show-current").strip()
+    tracked = tracked_branches(repo)
+    def is_ancestor(a: str, b: str) -> bool:
+        return subprocess.run(["git", "-C", str(repo), "merge-base", "--is-ancestor", a, b]).returncode == 0
+
+    for t in tracked:
+        if is_ancestor(t.upstream, t.branch):
+            continue                               # local contains the remote: fine
+        if not is_ancestor(t.branch, t.upstream):
+            raise RuntimeError(f"branch {t.branch} has diverged from {t.upstream}; reconcile it first")
+        if t.branch == current:
+            git(repo, "merge", "-q", "--ff-only", t.upstream)
+        else:
+            git(repo, "branch", "-q", "-f", t.branch, t.upstream)
+        print(f"  fast-forwarded {t.branch} to {t.upstream} (it was behind the remote)")
+    return tracked
+
+
+def push_rewritten(repo: Path, tracked: list[Tracked]) -> None:
+    """Force-push each tracked branch with an explicit lease on the commit seen at fetch time."""
+    if not tracked:
+        print("  no branch has an upstream; nothing to push")
+        return
+    for t in tracked:
+        git(repo, "push", "--quiet", f"--force-with-lease={t.remote_ref}:{t.oid}", t.remote,
+            f"refs/heads/{t.branch}:{t.remote_ref}")
+        print(f"  pushed {t.branch} -> {t.remote}/{t.remote_ref.removeprefix('refs/heads/')}")
+    for remote in sorted({t.remote for t in tracked}):
+        git(repo, "push", "--quiet", "--force", "--tags", remote)
+        print(f"  pushed tags -> {remote}")
+
+
+def clean(repo: Path, as_ident: str | None, push: bool) -> int:
+    if git(repo, "status", "--porcelain", "--untracked-files=no").strip():
+        raise RuntimeError("uncommitted changes to tracked files; commit or stash them first")
+    tracked = sync_with_remote(repo) if push else []
+    if as_ident is None:
+        name, email = git(repo, "config", "user.name").strip(), git(repo, "config", "user.email").strip()
+        as_ident = f"{name} <{email}>"
+    if not re.fullmatch(r"[^<>]+ <[^<>]+>", as_ident) or is_ai(as_ident):
+        raise RuntimeError(f"--as must be a human 'Name <email>', got {as_ident!r}")
+
+    backup = repo / ".git" / f"deai-backup-{time.strftime('%Y%m%d-%H%M%S')}.bundle"
+    git(repo, "bundle", "create", str(backup), "--branches", "--tags")
+
+    exp = subprocess.Popen(["git", "-C", str(repo), "fast-export", "--branches", "--tags",
+                            "--signed-tags=strip", "--use-done-feature"], stdout=subprocess.PIPE)
+    imp = subprocess.Popen(["git", "-C", str(repo), "fast-import", "--force", "--quiet"],
+                           stdin=subprocess.PIPE)
+    assert exp.stdout and imp.stdin
+    changed = rewrite_stream(exp.stdout, imp.stdin, as_ident.encode("utf-8"))
+    imp.stdin.close()
+    if exp.wait() or imp.wait():
+        raise RuntimeError(f"fast-export/fast-import failed; history is unchanged or restorable from {backup}")
+    git(repo, "reset", "-q", "--keep", "HEAD")    # trees are identical; refresh the index only
+    print(f"  rewrote {changed} commit(s); backup: {backup}")
+
+    if push:
+        push_rewritten(repo, tracked)
+    else:
+        print("  not pushed. Run again with --push to publish (it fetches first and never pushes a stale branch).")
+    return changed
+
+
+# ───────────── CLI ─────────────
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="deai", description=(__doc__ or "").split("\n\n")[0])
+    sub = ap.add_subparsers(dest="cmd", required=True)
+    for name, help_ in (("scan", "report AI credits, change nothing"),
+                        ("clean", "rewrite history without AI credits")):
+        p = sub.add_parser(name, help=help_)
+        p.add_argument("paths", nargs="*", help="repositories (default: current directory)")
+        p.add_argument("-r", "--recursive", action="store_true", help="find repositories below PATH")
+        p.add_argument("--me", action="append", default=[], metavar="EMAIL",
+                       help="another e-mail of yours (repeatable; git config user.email is always included)")
+    c = sub.choices["clean"]
+    c.add_argument("--yes", action="store_true", help="do not ask before rewriting")
+    c.add_argument("--push", action="store_true", help="force-push branches and tags afterwards")
+    c.add_argument("--as", dest="as_ident", metavar="'NAME <EMAIL>'",
+                   help="identity for AI-authored commits (default: git config user.*)")
+    c.add_argument("--include-shared", action="store_true",
+                   help="also rewrite repositories where other people's commits carry AI credits")
+    a = ap.parse_args(argv)
+
+    repos = find_repos(a.paths, a.recursive)
+    if not repos:
+        print("no repositories found", file=sys.stderr)
+        return 1
+    reports = [scan(r, a.me) for r in repos]
+    for rp in reports:
+        mark = "shared" if rp.others else "AI credits" if rp.dirty else "clean"
+        print(f"{mark:>10}  {rp.repo}  ({rp.commits} commits; trailers {len(rp.trailers)}, "
+              f"AI author/committer {len(rp.idents)})")
+        for kind, hs in (("trailer", rp.trailers), ("identity", rp.idents)):
+            if hs:
+                print(f"            {kind}: {' '.join(hs[:8])}{' ...' if len(hs) > 8 else ''}")
+        if rp.others:
+            names = sorted(rp.others)
+            print(f"            by others: {', '.join(names[:4])}{' ...' if len(names) > 4 else ''}")
+    if a.cmd == "scan":
+        if any(rp.others for rp in reports):
+            print("\n'shared': other people's commits are flagged (fork or shared history). "
+                  "clean skips these unless --include-shared; add --me for your other e-mails.")
+        return 0
+
+    todo = [rp for rp in reports if rp.dirty and (a.include_shared or not rp.others)]
+    for rp in reports:
+        if rp.dirty and rp.others and not a.include_shared:
+            print(f"skip {rp.repo}: shared history (see --include-shared)")
+    if not todo:
+        print("nothing to clean")
+        return 0
+    if not a.yes:
+        ans = input(f"Rewrite history of {len(todo)} repositor{'y' if len(todo) == 1 else 'ies'}? "
+                    "Commit hashes will change. [y/N] ")
+        if ans.strip().lower() not in ("y", "yes"):
+            print("aborted")
+            return 1
+    failed = 0
+    for rp in todo:
+        print(f"cleaning {rp.repo}")
+        try:
+            clean(rp.repo, a.as_ident, a.push)
+        except RuntimeError as e:
+            failed += 1
+            print(f"  error: {e}", file=sys.stderr)
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

git_deai-0.1.0.dist-info/METADATA

@@ -0,0 +1,266 @@
+Metadata-Version: 2.5
+Name: git-deai
+Version: 0.1.0
+Summary: Find and remove AI co-author credits from git history
+Project-URL: Homepage, https://github.com/NaNIsaac/deai
+Project-URL: Repository, https://github.com/NaNIsaac/deai
+Project-URL: Issues, https://github.com/NaNIsaac/deai/issues
+Author-email: Isaac Yong <isaacyong@naver.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,cli,co-author,git,history
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# deai
+
+**Remove AI co-author credits from your git history.**
+**git 기록에서 AI 공동저자 표시를 지웁니다.**
+
+[English](#english) · [한국어](#한국어)
+
+---
+
+## English
+
+### Why
+AI coding tools add a line like this to your commit messages:
+
+```
+Co-Authored-By: Claude <noreply@anthropic.com>
+```
+
+GitHub reads that line, so the tool then shows up in your repository's **Contributors** list. Copilot,
+Cursor, Codex and others do the same. `deai` finds these credits in all your repositories and
+rewrites the history without them. Your code does not change.
+
+### Install
+Requires Python 3.10+ and git. There are no other dependencies.
+
+```bash
+pip install git-deai
+# or, as an isolated tool
+uv tool install git-deai     # recommended
+pipx install git-deai
+# or, from a local clone
+uv tool install -e .
+```
+
+The package is `git-deai`; the command it installs is `deai`.
+To try it without installing: `uvx --from git-deai deai --help`.
+
+### Usage
+
+**1. Scan (read-only).** Scanning only reports; it changes nothing.
+
+```bash
+deai scan                          # the repository in the current directory
+deai scan path/to/repo             # one repository
+deai scan -r ~/code                # every repository under a folder
+```
+
+```
+AI credits  /home/me/code/my-app  (96 commits; trailers 51, AI author/committer 0)
+            trailer: faea929 e37c10a 2ce9a9c 7a5f1ab ...
+     clean  /home/me/code/notes   (8 commits; trailers 0, AI author/committer 0)
+    shared  /home/me/code/xarray  (6578 commits; trailers 96, AI author/committer 1)
+            by others: Deepak Cherian <...>, ...
+```
+
+| mark | meaning |
+|---|---|
+| `clean` | nothing to do |
+| `AI credits` | your commits carry AI credits; `clean` will fix them |
+| `shared` | someone else's commits carry AI credits (a fork or shared history); skipped by default |
+
+**2. Clean (rewrites history).**
+
+```bash
+deai clean path/to/repo            # shows the scan, asks y/N, backs up, rewrites
+deai clean -r ~/code               # every repository found (shared ones skipped)
+deai clean -r ~/code --yes --push  # no question; force-push afterwards
+```
+
+**3. Publish.** Without `--push`, nothing leaves your machine. When you are happy with the result,
+run the same command again with `--push`. Do not use `git push --all`: it would also push stale
+local branches over newer remote ones.
+
+GitHub can take a while to refresh the Contributors list after the push.
+
+### Options
+
+| option | commands | what it does |
+|---|---|---|
+| `-r`, `--recursive` | scan, clean | find repositories below each path |
+| `--me EMAIL` | scan, clean | another e-mail of yours (repeatable). `git config user.email` is always included. |
+| `--yes` | clean | do not ask before rewriting |
+| `--push` | clean | force-push branches (`--force-with-lease`) and tags afterwards |
+| `--as 'Name <email>'` | clean | identity for commits authored by an AI (default: `git config user.*`) |
+| `--include-shared` | clean | also rewrite `shared` repositories (rarely what you want) |
+
+### What is removed
+- `Co-authored-by:` trailers whose name or e-mail matches an AI tool. **Human co-authors stay.**
+- "Generated with \<AI tool\>" lines, e.g. `🤖 Generated with [Claude Code](https://claude.com/claude-code)`.
+- AI author and committer identities, which are re-attributed to you.
+
+Matched tools: Claude/Anthropic, GitHub Copilot, Cursor, ChatGPT/OpenAI/Codex, Gemini, Devin, Aider,
+Codeium/Windsurf, Tabnine, CodeWhisperer/Amazon Q, Jules, Sweep.
+
+### Safety
+- **A clean worktree is required.** `clean` refuses to run if tracked files have uncommitted changes.
+- **A backup is made first.** Every branch and tag is saved to `.git/deai-backup-<time>.bundle`.
+  To restore it:
+  ```bash
+  git fetch --force .git/deai-backup-20261014-222005.bundle 'refs/*:refs/*'
+  ```
+- **Pushes never lose remote commits.** `--push` fetches first.
+  - A local branch that is behind its remote is fast-forwarded before the rewrite.
+  - A branch that has diverged from its remote stops the run.
+  - Each branch is force-pushed with an explicit lease on the commit seen at fetch time.
+  - Only branches with an upstream are pushed; local-only branches stay local.
+- **Forks are protected.** A repository whose flagged commits were written by other people is
+  marked `shared` and skipped. Rewriting it would split your fork from upstream.
+
+### Things to know
+- **Commit hashes change** from the first cleaned commit onward. Anyone else with a clone must
+  re-clone (or `git fetch && git reset --hard origin/<branch>`).
+- **Open pull requests** from a rewritten branch need to be re-created.
+- **GPG-signed commits** lose their signatures, because the signed content changed.
+- **Protected branches** on GitHub may reject the force-push. Allow force-pushes temporarily, or push
+  to a new branch.
+
+### Stop it from coming back
+Turn the attribution off in your AI tool. In Claude Code, add this to `~/.claude/settings.json`
+(an empty string removes that line; the older `includeCoAuthoredBy` is deprecated):
+
+```json
+{ "attribution": { "commit": "", "pr": "" } }
+```
+
+### How it works
+`git fast-export --branches --tags` → message filter (stdlib Python) → `git fast-import --force`.
+There is no git-filter-repo dependency. File contents are passed through untouched, so every tree is
+byte-identical to the original.
+
+### Test
+```bash
+python tests/test_deai.py
+```
+
+---
+
+## 한국어
+
+### 왜 필요한가요
+AI 코딩 도구는 커밋 메시지 끝에 이런 줄을 붙입니다.
+
+```
+Co-Authored-By: Claude <noreply@anthropic.com>
+```
+
+GitHub는 이 줄을 읽어서 저장소의 **Contributors** 목록에 AI를 올립니다. Copilot, Cursor, Codex 등도
+마찬가지입니다. `deai`는 내 저장소 전체에서 이런 표시를 찾아 git 기록에서 지웁니다. 코드는 그대로입니다.
+
+### 설치
+Python 3.10 이상과 git만 있으면 됩니다. 다른 의존성은 없습니다.
+
+```bash
+pip install git-deai
+# 또는 격리된 도구로
+uv tool install git-deai     # 추천
+pipx install git-deai
+# 또는 내려받은 폴더에서
+uv tool install -e .
+```
+
+패키지 이름은 `git-deai`이고, 설치되는 명령어는 `deai`입니다.
+설치 없이 써 보려면: `uvx --from git-deai deai --help`
+
+### 사용법
+
+**1. 점검 (읽기만 함).** 결과만 보여주고 아무것도 바꾸지 않습니다.
+
+```bash
+deai scan                          # 현재 폴더의 저장소
+deai scan 경로/저장소               # 저장소 하나
+deai scan -r ~/code                # 폴더 아래 모든 저장소
+```
+
+| 표시 | 뜻 |
+|---|---|
+| `clean` | 고칠 것 없음 |
+| `AI credits` | 내 커밋에 AI 표시가 있음. `clean`으로 지울 수 있음 |
+| `shared` | **다른 사람** 커밋에 AI 표시가 있음 (fork 등). 기본적으로 건너뜀 |
+
+**2. 정리 (기록을 다시 씀).**
+
+```bash
+deai clean 경로/저장소              # 점검 결과 → y/N 확인 → 백업 → 다시 쓰기
+deai clean -r ~/code               # 찾은 저장소 전부 (shared는 제외)
+deai clean -r ~/code --yes --push  # 확인 없이, 끝나면 force-push까지
+```
+
+**3. GitHub에 반영.** `--push`를 붙이지 않으면 내 컴퓨터 밖으로 아무것도 나가지 않습니다. 결과를 확인한 뒤
+같은 명령에 `--push`를 붙여 다시 실행하세요. `git push --all`은 쓰지 마세요. 원격보다 뒤처진 로컬 브랜치까지
+덮어써서 원격의 최신 커밋이 사라질 수 있습니다.
+
+push한 뒤 GitHub의 Contributors 목록이 갱신되기까지 시간이 좀 걸릴 수 있습니다.
+
+### 옵션
+
+| 옵션 | 명령 | 하는 일 |
+|---|---|---|
+| `-r`, `--recursive` | scan, clean | 경로 아래 저장소를 모두 찾음 |
+| `--me EMAIL` | scan, clean | 내 다른 이메일 (여러 번 지정 가능). `git config user.email`은 항상 포함 |
+| `--yes` | clean | 확인 질문 없이 진행 |
+| `--push` | clean | 끝나면 브랜치(`--force-with-lease`)와 태그를 force-push |
+| `--as '이름 <이메일>'` | clean | AI가 작성자로 된 커밋을 바꿀 이름 (기본값: `git config user.*`) |
+| `--include-shared` | clean | `shared` 저장소도 다시 씀 (보통은 쓰지 마세요) |
+
+### 지우는 것
+- AI 도구 이름이나 이메일이 들어간 `Co-authored-by:` 줄. **사람 공동저자 줄은 남깁니다.**
+- `🤖 Generated with [Claude Code](...)` 같은 "Generated with \<AI 도구\>" 줄
+- AI가 작성자나 커미터로 된 커밋. 이 커밋들은 내 이름으로 바꿉니다.
+
+### 안전장치
+- **커밋 안 한 변경이 있으면 실행하지 않습니다.**
+- **먼저 백업합니다.** 모든 브랜치와 태그를 `.git/deai-backup-<시각>.bundle`로 저장합니다. 되돌리려면:
+  ```bash
+  git fetch --force .git/deai-backup-20261014-222005.bundle 'refs/*:refs/*'
+  ```
+- **원격 커밋을 잃지 않습니다.** `--push`를 붙이면 먼저 fetch합니다.
+  - 원격보다 뒤처진 로컬 브랜치는 먼저 fast-forward합니다.
+  - 원격과 갈라진 브랜치가 있으면 멈춥니다.
+  - 브랜치마다 fetch 시점의 커밋을 lease로 걸어 force-push합니다.
+  - upstream이 있는 브랜치만 push하고, 로컬 전용 브랜치는 그대로 둡니다.
+- **fork는 보호합니다.** 다른 사람이 쓴 커밋이 걸린 저장소는 `shared`로 표시하고 건너뜁니다.
+  다시 쓰면 upstream과 기록이 갈라지기 때문입니다.
+
+### 알아둘 점
+- **커밋 해시가 바뀝니다.** 처음 고쳐진 커밋부터 그 뒤가 모두 바뀝니다. 다른 사람이 clone해 둔 저장소는
+  다시 clone하거나 `git fetch && git reset --hard origin/<브랜치>`를 해야 합니다.
+- **열린 PR**이 다시 쓴 브랜치에 있으면 PR을 새로 만들어야 합니다.
+- **GPG 서명**은 사라집니다. 서명한 내용이 바뀌었기 때문입니다.
+- **보호된 브랜치**는 force-push가 거절될 수 있습니다. 잠깐 허용하거나 새 브랜치로 push하세요.
+
+### 다시 생기지 않게 하기
+AI 도구에서 공동저자 표시를 끄세요. Claude Code라면 `~/.claude/settings.json`에 다음을 넣습니다
+(빈 문자열이면 그 줄을 넣지 않습니다. 예전 설정 `includeCoAuthoredBy`는 deprecated입니다).
+
+```json
+{ "attribution": { "commit": "", "pr": "" } }
+```
+
+### 동작 방식
+`git fast-export --branches --tags` → 메시지 필터(표준 라이브러리 Python) → `git fast-import --force`.
+git-filter-repo가 필요 없습니다. 파일 내용은 손대지 않으므로 모든 트리가 원래와 바이트 단위로 같습니다.
+
+---
+
+MIT License

git_deai-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+deai/__init__.py,sha256=grRPcM80gzRAjhRdM31PsmuTg0L2W6MDDalU8jp5sLk,67
+deai/cli.py,sha256=dIRKbRULoNeIVI-xS8oiY_4KuiDs-BL01FeR4RMkuJc,15322
+git_deai-0.1.0.dist-info/METADATA,sha256=9aeD1NxcxemwslrzlYqb0O33iX1fc8bXiVZd3v-0JBU,11374
+git_deai-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+git_deai-0.1.0.dist-info/entry_points.txt,sha256=5pcNEvTgoCpa9tC0Lq82FMC7JqHwcHNHsEgp1G1wcM4,39
+git_deai-0.1.0.dist-info/licenses/LICENSE,sha256=hMVbLViuzZqpmkib0hPsT09tXZ5PARWhGbDgDszcyVc,1067
+git_deai-0.1.0.dist-info/RECORD,,

git_deai-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

git_deai-0.1.0.dist-info/entry_points.txt

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

git_deai-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isaac Yong
+
+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.