aishare 0.1.0__py3-none-any.whl

aishare/__init__.py

@@ -0,0 +1,2 @@
+"""How much of the code you shipped did AI write?"""
+__version__ = "0.1.0"

aishare/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

aishare/agentlogs.py

@@ -0,0 +1,353 @@
+"""Read the session logs that AI coding agents keep on your machine, into one common shape.
+
+Supported (all read-only, nothing leaves your machine):
+- Claude Code:  ~/.claude/projects/<project>/<session>.jsonl (and subagent logs under it)
+- Codex CLI:    ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+- Gemini CLI:   ~/.gemini/tmp/<project>/chats/session-*.json(l), with ~/.gemini/projects.json for folders
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+AGENTS = {"claude": "Claude Code", "codex": "Codex", "gemini": "Gemini CLI"}
+
+
+@dataclass
+class Event:
+    agent: str  # "claude" | "codex" | "gemini"
+    session: str
+    ts: float | None
+    cwd: str | None
+    kind: str  # "prompt" | "command" | "read" | "write" | "edit" | "fetch" | "tool"
+    tool: str = ""
+    command: str = ""  # shell command line
+    path: str = ""  # file read/written
+    added: list[str] = field(default_factory=list)  # lines the agent wrote
+    text: str = ""  # prompt text, URL, etc.
+    model: str = ""
+    tokens: int = 0  # tokens used by this turn, where the log says
+
+
+def parse_ts(s) -> float | None:
+    if not s:
+        return None
+    if isinstance(s, (int, float)):
+        return float(s) / (1000 if s > 1e11 else 1)
+    try:
+        return datetime.fromisoformat(str(s).replace("Z", "+00:00")).timestamp()
+    except ValueError:
+        return None
+
+
+def _lines(text: str) -> list[str]:
+    return text.splitlines() if isinstance(text, str) else []
+
+
+def _jsonl(path: Path) -> Iterator[dict]:
+    try:
+        with path.open(encoding="utf-8", errors="replace") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    d = json.loads(line)
+                except ValueError:
+                    continue
+                if isinstance(d, dict):
+                    yield d
+    except OSError:
+        return
+
+
+# ---------------------------------------------------------------------------
+# Claude Code
+# ---------------------------------------------------------------------------
+def claude_root() -> Path:
+    return Path(os.environ.get("CLAUDE_CONFIG_DIR") or Path.home() / ".claude") / "projects"
+
+
+def _prompt_text(content) -> str:
+    if isinstance(content, str):
+        return content
+    if isinstance(content, list):
+        return "\n".join(b.get("text", "") for b in content if isinstance(b, dict) and b.get("type") == "text")
+    return ""
+
+
+def claude_events(path: Path) -> Iterator[Event]:
+    for d in _jsonl(path):
+        typ = d.get("type")
+        if typ not in ("user", "assistant"):
+            continue
+        ts, cwd, sid = parse_ts(d.get("timestamp")), d.get("cwd"), d.get("sessionId") or path.stem
+        msg = d.get("message") or {}
+        content = msg.get("content")
+        if typ == "user":
+            if d.get("isMeta") or d.get("isCompactSummary") or d.get("toolUseResult") is not None:
+                continue
+            text = _prompt_text(content)
+            if text and not text.startswith(("<command-", "<local-command", "Caveat:", "[Request interrupted")) \
+                    and not (isinstance(content, list) and any(b.get("type") == "tool_result" for b in content
+                                                               if isinstance(b, dict))):
+                yield Event("claude", sid, ts, cwd, "prompt", text=text)
+            continue
+        usage = msg.get("usage") or {}
+        tokens = sum(int(usage.get(k) or 0) for k in ("input_tokens", "output_tokens", "cache_creation_input_tokens"))
+        model = msg.get("model") or ""
+        first = True
+        for b in content if isinstance(content, list) else []:
+            if not isinstance(b, dict) or b.get("type") != "tool_use":
+                continue
+            name, inp = b.get("name") or "", b.get("input") or {}
+            ev = Event("claude", sid, ts, cwd, "tool", tool=name, model=model, tokens=tokens if first else 0)
+            first = False
+            if name == "Bash":
+                ev.kind, ev.command = "command", str(inp.get("command") or "")
+            elif name in ("Read", "NotebookRead"):
+                ev.kind, ev.path = "read", str(inp.get("file_path") or inp.get("notebook_path") or "")
+            elif name == "Write":
+                ev.kind, ev.path, ev.added = "write", str(inp.get("file_path") or ""), _lines(inp.get("content", ""))
+            elif name == "Edit":
+                ev.kind, ev.path, ev.added = "edit", str(inp.get("file_path") or ""), _lines(inp.get("new_string", ""))
+            elif name == "MultiEdit":
+                ev.kind, ev.path = "edit", str(inp.get("file_path") or "")
+                for e in inp.get("edits") or []:
+                    ev.added += _lines((e or {}).get("new_string", ""))
+            elif name == "NotebookEdit":
+                ev.kind, ev.path, ev.added = "edit", str(inp.get("notebook_path") or ""), _lines(inp.get("new_source", ""))
+            elif name in ("WebFetch", "WebSearch"):
+                ev.kind, ev.text = "fetch", str(inp.get("url") or inp.get("query") or "")
+            elif name in ("Grep", "Glob", "LS"):
+                ev.kind, ev.path = "read", str(inp.get("path") or "")
+            yield ev
+        if first and tokens:  # a turn with no tool calls still used tokens
+            yield Event("claude", sid, ts, cwd, "tool", tool="", model=model, tokens=tokens)
+
+
+# ---------------------------------------------------------------------------
+# Codex CLI
+# ---------------------------------------------------------------------------
+def codex_root() -> Path:
+    return Path(os.environ.get("CODEX_HOME") or Path.home() / ".codex") / "sessions"
+
+
+PATCH_FILE = re.compile(r"^\*\*\* (Add|Update|Delete) File: (.+)$")
+
+
+def parse_apply_patch(patch: str) -> list[tuple[str, list[str]]]:
+    """[(path, added lines)] from Codex's *** Begin Patch format."""
+    out: list[tuple[str, list[str]]] = []
+    for line in patch.splitlines():
+        m = PATCH_FILE.match(line)
+        if m:
+            out.append((m.group(2).strip(), []))
+        elif out and line.startswith("+") and not line.startswith("+++"):
+            out[-1][1].append(line[1:])
+    return out
+
+
+def _codex_command(name: str, args) -> str:
+    if isinstance(args, str):
+        try:
+            args = json.loads(args)
+        except ValueError:
+            return args if name in ("shell_command",) else ""
+    if not isinstance(args, dict):
+        return ""
+    cmd = args.get("cmd", args.get("command"))
+    if isinstance(cmd, list):
+        # ["bash", "-lc", "real command"] -> "real command"
+        if len(cmd) >= 3 and cmd[1] in ("-lc", "-c") and os.path.basename(str(cmd[0])) in ("bash", "sh", "zsh"):
+            return str(cmd[2])
+        return " ".join(str(c) for c in cmd)
+    return str(cmd or "")
+
+
+def codex_events(path: Path) -> Iterator[Event]:
+    sid, cwd, model = path.stem.replace("rollout-", ""), None, ""
+    last_total = 0
+    for d in _jsonl(path):
+        typ, p = d.get("type"), d.get("payload") or {}
+        ts = parse_ts(d.get("timestamp"))
+        if typ == "session_meta":
+            sid = str(p.get("id") or p.get("session_id") or sid)
+            cwd = p.get("cwd") or cwd
+            continue
+        if typ == "turn_context":
+            cwd = p.get("cwd") or cwd
+            model = p.get("model") or model
+            continue
+        if typ == "event_msg":
+            if p.get("type") == "user_message" and p.get("message"):
+                yield Event("codex", sid, ts, cwd, "prompt", text=str(p["message"]))
+            elif p.get("type") == "token_count" and isinstance(p.get("info"), dict):
+                total = (p["info"].get("total_token_usage") or {}).get("total_tokens") or 0
+                if total > last_total:
+                    yield Event("codex", sid, ts, cwd, "tool", model=model, tokens=int(total - last_total))
+                    last_total = total
+            continue
+        if typ != "response_item":
+            continue
+        ptype, name = p.get("type"), p.get("name") or ""
+        if ptype == "local_shell_call":
+            cmd = _codex_command("shell", (p.get("action") or {}))
+            yield Event("codex", sid, ts, cwd, "command", tool="local_shell", command=cmd, model=model)
+        elif ptype in ("function_call", "custom_tool_call"):
+            raw = p.get("arguments") if ptype == "function_call" else p.get("input")
+            if name == "apply_patch":
+                patch = raw
+                if ptype == "function_call":
+                    try:
+                        patch = json.loads(raw).get("input", "")
+                    except (ValueError, AttributeError):
+                        patch = ""
+                for fpath, added in parse_apply_patch(patch or ""):
+                    yield Event("codex", sid, ts, cwd, "edit", tool="apply_patch", path=fpath, added=added, model=model)
+            elif name in ("shell", "exec_command", "shell_command", "container.exec"):
+                cmd = _codex_command(name, raw)
+                if "apply_patch" in cmd and "*** Begin Patch" in cmd:  # older Codex sent patches through the shell
+                    for fpath, added in parse_apply_patch(cmd):
+                        yield Event("codex", sid, ts, cwd, "edit", tool="apply_patch", path=fpath, added=added,
+                                    model=model)
+                else:
+                    yield Event("codex", sid, ts, cwd, "command", tool=name, command=cmd, model=model)
+            elif name in ("web_search", "web_fetch"):
+                yield Event("codex", sid, ts, cwd, "fetch", tool=name, text=str(raw)[:300], model=model)
+            else:
+                yield Event("codex", sid, ts, cwd, "tool", tool=name, model=model)
+
+
+# ---------------------------------------------------------------------------
+# Gemini CLI
+# ---------------------------------------------------------------------------
+def gemini_home() -> Path:
+    return Path.home() / ".gemini"
+
+
+def gemini_projects() -> dict[str, str]:
+    """shortId -> project folder, from ~/.gemini/projects.json."""
+    for base in (gemini_home(), Path.home() / ".cache" / ".gemini"):
+        try:
+            data = json.loads((base / "projects.json").read_text())
+            return {v: k for k, v in (data.get("projects") or {}).items()}
+        except (OSError, ValueError, AttributeError):
+            continue
+    return {}
+
+
+def _gemini_records(path: Path) -> tuple[dict, list[dict]]:
+    """(metadata, messages) for both the old single-JSON and the newer JSONL session files."""
+    if path.suffix == ".json":
+        try:
+            data = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+        except (OSError, ValueError):
+            return {}, []
+        return data, list(data.get("messages") or [])
+    meta: dict = {}
+    msgs: dict[str, dict] = {}
+    order: list[str] = []
+    for d in _jsonl(path):
+        if "sessionId" in d and "projectHash" in d and "type" not in d:
+            meta.update(d)
+        elif "$set" in d:
+            meta.update(d["$set"] if isinstance(d["$set"], dict) else {})
+        elif isinstance(d.get("id"), str):
+            if d["id"] in msgs:  # a later patch of the same message (e.g. tool results filled in)
+                cur = msgs[d["id"]]
+                for k, v in d.items():
+                    if k == "toolCalls" and isinstance(v, list):
+                        known = {t.get("id"): t for t in cur.get("toolCalls") or []}
+                        for t in v:
+                            known.setdefault(t.get("id"), {}).update(t)
+                        cur["toolCalls"] = list(known.values())
+                    elif k != "$patch":
+                        cur[k] = v
+            else:
+                msgs[d["id"]] = dict(d)
+                order.append(d["id"])
+    return meta, [msgs[i] for i in order]
+
+
+def gemini_events(path: Path, projects: dict[str, str] | None = None) -> Iterator[Event]:
+    meta, messages = _gemini_records(path)
+    sid = str(meta.get("sessionId") or path.stem)
+    short = path.parent.parent.name if path.parent.name == "chats" else ""
+    cwd = (projects or {}).get(short)
+    for m in messages:
+        ts = parse_ts(m.get("timestamp"))
+        if m.get("type") == "user":
+            text = m.get("content")
+            if isinstance(text, list):
+                text = "\n".join(p.get("text", "") for p in text if isinstance(p, dict))
+            if text:
+                yield Event("gemini", sid, ts, cwd, "prompt", text=str(text))
+            continue
+        if m.get("type") != "gemini":
+            continue
+        tok = m.get("tokens") or {}
+        tokens = int(tok.get("total") or 0) if isinstance(tok, dict) else 0
+        model = m.get("model") or ""
+        calls = m.get("toolCalls") or []
+        for i, tc in enumerate(calls):
+            name, args = tc.get("name") or "", tc.get("args") or {}
+            ev = Event("gemini", sid, parse_ts(tc.get("timestamp")) or ts, cwd, "tool", tool=name, model=model,
+                       tokens=tokens if i == 0 else 0)
+            if name in ("run_shell_command", "ShellTool"):
+                ev.kind, ev.command = "command", str(args.get("command") or "")
+                if args.get("dir_path") and not cwd:
+                    ev.cwd = str(args["dir_path"])
+            elif name == "write_file":
+                ev.kind, ev.path, ev.added = "write", str(args.get("file_path") or ""), _lines(args.get("content", ""))
+            elif name in ("replace", "edit"):
+                ev.kind, ev.path, ev.added = "edit", str(args.get("file_path") or ""), _lines(args.get("new_string", ""))
+            elif name in ("read_file", "read_many_files", "glob", "search_file_content", "grep_search", "list_directory"):
+                ev.kind = "read"
+                ev.path = str(args.get("file_path") or args.get("absolute_path") or args.get("path") or
+                              args.get("dir_path") or "")
+            elif name in ("web_fetch", "google_web_search"):
+                ev.kind, ev.text = "fetch", str(args.get("url") or args.get("prompt") or args.get("query") or "")[:300]
+            yield ev
+        if not calls and tokens:
+            yield Event("gemini", sid, ts, cwd, "tool", model=model, tokens=tokens)
+
+
+# ---------------------------------------------------------------------------
+# Everything
+# ---------------------------------------------------------------------------
+def session_files(roots: dict[str, Path] | None = None) -> list[tuple[str, Path]]:
+    roots = roots or {"claude": claude_root(), "codex": codex_root(), "gemini": gemini_home() / "tmp"}
+    out: list[tuple[str, Path]] = []
+    if roots.get("claude") and roots["claude"].is_dir():
+        out += [("claude", p) for p in sorted(roots["claude"].rglob("*.jsonl"))]
+    if roots.get("codex") and roots["codex"].is_dir():
+        out += [("codex", p) for p in sorted(roots["codex"].rglob("rollout-*.jsonl"))]
+    if roots.get("gemini") and roots["gemini"].is_dir():
+        out += [("gemini", p) for p in sorted(roots["gemini"].glob("*/chats/session-*.json*"))]
+    return out
+
+
+def all_events(roots: dict[str, Path] | None = None, since: float | None = None) -> Iterator[Event]:
+    projects = gemini_projects()
+    for agent, path in session_files(roots):
+        try:
+            if since and path.stat().st_mtime < since:
+                continue  # untouched since before the window: nothing in it can be newer
+        except OSError:
+            continue
+        if agent == "claude":
+            it = claude_events(path)
+        elif agent == "codex":
+            it = codex_events(path)
+        else:
+            it = gemini_events(path, projects)
+        for ev in it:
+            if since and ev.ts and ev.ts < since:
+                continue
+            yield ev

aishare/cli.py

@@ -0,0 +1,170 @@
+"""aishare: how much of the code you shipped did AI write?"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import time
+from datetime import datetime
+from pathlib import Path
+
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import __version__, agentlogs
+from .share import NAMES, AgentIndex, Summary, analyze_repo, find_repos, identities
+
+COLORS = {"claude": "#d97757", "codex": "#10a37f", "gemini": "#4285f4", "copilot": "#a371f7", "cursor": "#e6e6e6",
+          "aider": "#14b014", "devin": "#3b82f6", "windsurf": "#09b6a2", "amp": "#f34e3f", "you": "#5c6370"}
+
+
+def bar(parts: list[tuple[str, int]], total: int, width: int = 48) -> Text:
+    t = Text()
+    used = 0
+    for key, n in parts:
+        w = round(width * n / total) if total else 0
+        w = min(w, width - used)
+        if n and w == 0:
+            w = 1
+        t.append("█" * w, COLORS.get(key, "white"))
+        used += w
+    if used < width:
+        t.append("█" * (width - used), COLORS["you"])
+    return t
+
+
+def render(s: Summary, console: Console, top: int = 8) -> None:
+    if not s.total:
+        console.print(Text("No lines of yours from that period are still in these repos. "
+                           "Try a wider window with --since, or point it at a folder of repos.", "yellow"))
+        return
+    head = Text.assemble((f"{s.share:.0%}", "bold #d97757"), " of the code you shipped ", s.period(),
+                         " was written by ", ("AI", "bold"), ".")
+    parts: list = [head, Text(f"{s.ai:,} of {s.total:,} lines still in your code, across {len(s.repos)} "
+                              f"repo{'s' * (len(s.repos) != 1)}", "dim"), Text("")]
+    agents = s.by_agent.most_common()
+    parts.append(bar(agents, s.total))
+    legend = Text()
+    for a, n in agents:
+        legend.append("■ ", COLORS.get(a, "white"))
+        legend.append(f"{NAMES.get(a, a)} {n / s.total:.0%}   ")
+    legend.append("■ ", COLORS["you"])
+    legend.append(f"You {1 - s.share:.0%}")
+    parts += [legend, Text("")]
+
+    months = s.months()
+    if len(months) > 1:
+        g = Table.grid(padding=(0, 1))
+        g.add_column(no_wrap=True, style="dim")
+        g.add_column()
+        g.add_column(justify="right", style="dim")
+        for m, c in months.items():
+            tot = sum(c.values())
+            ai = tot - c.get("you", 0)
+            label = datetime.strptime(m, "%Y-%m").strftime("%b")
+            g.add_row(label, bar([(a, n) for a, n in c.most_common() if a != "you"], tot, 30),
+                      f"{ai / tot:.0%}" if tot else "")
+        parts += [Text("Month by month", "bold"), g, Text("")]
+
+    repos = sorted((r for r in s.repos if r.total), key=lambda r: -r.total)
+    if repos:
+        t = Table(box=None, header_style="dim", padding=(0, 2))
+        t.add_column("Repo", no_wrap=True)
+        t.add_column("Your lines", justify="right")
+        t.add_column("AI", justify="right")
+        t.add_column("Mostly", no_wrap=True)
+        for r in repos[:top]:
+            main = r.by_agent.most_common(1)
+            t.add_row(Text(r.repo.name, "bold"), f"{r.total:,}", f"{r.ai / r.total:.0%}",
+                      Text(NAMES.get(main[0][0], main[0][0]), COLORS.get(main[0][0], "")) if main else Text("—", "dim"))
+        if len(repos) > top:
+            t.add_row(Text(f"+ {len(repos) - top} more", "dim"), "", "", "")
+        parts += [t, Text("")]
+
+    via_logs = sum(r.via_logs for r in s.repos)
+    via_tr = sum(r.via_trailers for r in s.repos)
+    how = []
+    if via_logs:
+        how.append(f"{via_logs:,} lines matched to agent session logs")
+    if via_tr:
+        how.append(f"{via_tr:,} from commits with an AI co-author")
+    if how:
+        parts.append(Text("How we know: " + "; ".join(how) + ".", "dim"))
+    if not s.log_events:
+        parts.append(Text("No Claude Code, Codex or Gemini CLI logs found here, so only commit co-author trailers "
+                          "were counted.", "dim"))
+    console.print(Panel(Group(*parts), title="[bold]Who wrote your code?[/]", border_style="#d97757", padding=(1, 2)))
+    console.print(Text("  Share: ", "dim") + Text(s.share_line(), "italic"))
+    console.print()
+
+
+def parse_date(s: str) -> float:
+    for fmt in ("%Y-%m-%d", "%Y-%m", "%Y"):
+        try:
+            return time.mktime(datetime.strptime(s, fmt).timetuple())
+        except ValueError:
+            continue
+    raise argparse.ArgumentTypeError(f"not a date: {s} (use YYYY, YYYY-MM or YYYY-MM-DD)")
+
+
+def main(argv: list[str] | None = None) -> int:
+    ap = argparse.ArgumentParser(prog="aishare", description="How much of the code you shipped did AI write? "
+                                 "Matches git blame against your AI agents' session logs and AI co-author trailers.")
+    ap.add_argument("paths", nargs="*", default=["."], help="repos, or folders to search for repos (default: .)")
+    ap.add_argument("--since", type=parse_date, help="start of the window (default: Jan 1 this year)")
+    ap.add_argument("--until", type=parse_date, help="end of the window (default: now)")
+    ap.add_argument("--email", action="append", default=[], help="another email or name you commit as (repeatable)")
+    ap.add_argument("--top", type=int, default=8, help="rows in the repo table")
+    ap.add_argument("--json", action="store_true", help="print numbers as JSON")
+    ap.add_argument("-V", "--version", action="version", version=f"aishare {__version__}")
+    a = ap.parse_args(argv)
+    console = Console(stderr=a.json)
+
+    now = time.time()
+    since = a.since or time.mktime((time.localtime(now).tm_year, 1, 1, 0, 0, 0, 0, 0, -1))
+    until = a.until or now
+    me = identities(a.email)
+    if not me:
+        console.print("[yellow]Couldn't read your git identity.[/] Set it with git config --global user.email, "
+                      "or pass --email you@example.com")
+        return 2
+    repos = find_repos([Path(p) for p in a.paths])
+    if not repos:
+        console.print("[yellow]No git repos found there.[/]")
+        return 2
+
+    index = AgentIndex()
+    seen = {}
+    with console.status("Reading agent session logs…") if not a.json else _null():
+        for ev in agentlogs.all_events(since=since - 86400):
+            index.add(ev)
+            seen[ev.agent] = seen.get(ev.agent, 0) + 1
+    results = []
+    with console.status(f"Running git blame across {len(repos)} repo(s)…") if not a.json else _null():
+        for r in repos:
+            results.append(analyze_repo(r, me, since, until, index))
+    s = Summary(results, since, until, log_events=index.events)
+    if a.json:
+        print(json.dumps({
+            "since": since, "until": until, "lines": s.total, "ai_lines": s.ai, "share": round(s.share, 4),
+            "by_agent": dict(s.by_agent), "months": {m: dict(c) for m, c in s.months().items()},
+            "repos": [{"repo": str(r.repo), "lines": r.total, "ai_lines": r.ai, "by_agent": dict(r.by_agent),
+                       "via_logs": r.via_logs, "via_trailers": r.via_trailers} for r in results],
+        }, indent=2))
+    else:
+        render(s, console, a.top)
+    return 0
+
+
+class _null:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *a):
+        return False
+
+
+if __name__ == "__main__":
+    sys.exit(main())

aishare/share.py

@@ -0,0 +1,296 @@
+"""Who wrote the code you shipped? Match the lines git blames on you against what your AI agents wrote."""
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from collections import Counter, defaultdict
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .agentlogs import Event
+
+# Commit trailers and bodies that name an AI tool. (agent key, pattern)
+TRAILER_AGENTS = [
+    ("claude", re.compile(r"noreply@anthropic\.com|\bclaude\b|claude\.ai/code|claude\.com/claude-code", re.I)),
+    ("codex", re.compile(r"\bcodex\b|openai\.com", re.I)),
+    ("copilot", re.compile(r"\bcopilot\b|copilot-swe-agent", re.I)),
+    ("cursor", re.compile(r"cursoragent@cursor\.com|\bcursor agent\b|\bcursor\b", re.I)),
+    ("gemini", re.compile(r"\bgemini\b|gemini-code-assist|google-labs-jules|\bjules\b", re.I)),
+    ("aider", re.compile(r"\baider\b", re.I)),
+    ("devin", re.compile(r"\bdevin\b|devin-ai-integration", re.I)),
+    ("windsurf", re.compile(r"\bwindsurf\b|\bcodeium\b|\bcascade\b", re.I)),
+    ("amp", re.compile(r"ampcode\.com", re.I)),
+]
+AI_LINE = re.compile(r"^(co-authored-by|generated[- ]by|generated with|assisted-by|ai-assisted):", re.I)
+GENERATED_WITH = re.compile(r"generated with \[?(claude code|codex|cursor|gemini|aider|copilot)", re.I)
+BOT_AUTHORS = re.compile(r"copilot-swe-agent|devin-ai-integration|google-labs-jules|cursor.*agent|claude\[bot\]|"
+                         r"codex\[bot\]|openai-codex", re.I)
+
+NAMES = {"claude": "Claude", "codex": "Codex", "gemini": "Gemini", "copilot": "Copilot", "cursor": "Cursor",
+         "aider": "Aider", "devin": "Devin", "windsurf": "Windsurf", "amp": "Amp"}
+
+
+def norm(line: str) -> str | None:
+    """Whitespace-insensitive form of a line, or None for lines too trivial to attribute (braces, blanks)."""
+    s = re.sub(r"\s+", " ", line.strip())
+    if len(s) < 4 or not re.search(r"[A-Za-z0-9]{2}", s):
+        return None
+    return s
+
+
+def git(repo: Path, *args: str, check: bool = False) -> str:
+    try:
+        p = subprocess.run(["git", "-C", str(repo), *args], capture_output=True, text=True, errors="replace",
+                           timeout=300)
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    if check and p.returncode:
+        raise RuntimeError(p.stderr.strip())
+    return p.stdout
+
+
+def find_repos(paths: list[Path], depth: int = 4) -> list[Path]:
+    out: list[Path] = []
+    skip = {"node_modules", ".venv", "venv", "vendor", "target", "dist", "build", "Library", ".cache", ".Trash"}
+
+    def walk(d: Path, level: int):
+        if (d / ".git").exists():
+            out.append(d)
+            return
+        if level >= depth:
+            return
+        try:
+            for c in sorted(d.iterdir()):
+                if c.is_dir() and not c.is_symlink() and not c.name.startswith(".") and c.name not in skip:
+                    walk(c, level + 1)
+        except OSError:
+            pass
+
+    for p in paths:
+        p = p.expanduser().resolve()
+        top = git(p, "rev-parse", "--show-toplevel").strip()
+        if top:
+            out.append(Path(top))
+        else:
+            walk(p, 0)
+    seen, uniq = set(), []
+    for r in out:
+        if r not in seen:
+            seen.add(r)
+            uniq.append(r)
+    return uniq
+
+
+def identities(extra: list[str] = ()) -> set[str]:
+    ids = {e.lower() for e in extra}
+    for key in ("user.email", "user.name"):
+        try:
+            v = subprocess.run(["git", "config", "--global", key], capture_output=True, text=True).stdout.strip()
+        except OSError:
+            v = ""
+        if v:
+            ids.add(v.lower())
+    return ids
+
+
+def trailer_agent(message: str) -> str | None:
+    for line in message.splitlines():
+        line = line.strip()
+        if AI_LINE.match(line) or GENERATED_WITH.search(line):
+            for key, rx in TRAILER_AGENTS:
+                if rx.search(line):
+                    return key
+    return None
+
+
+@dataclass
+class AgentLine:
+    agent: str
+    ts: float
+
+
+class AgentIndex:
+    """Lines each agent wrote, per absolute file path, with when it wrote them."""
+
+    def __init__(self):
+        self.by_file: dict[str, dict[str, list[AgentLine]]] = defaultdict(lambda: defaultdict(list))
+        self.events = 0
+
+    def add(self, ev: Event) -> None:
+        if ev.kind not in ("write", "edit") or not ev.path or not ev.added:
+            return
+        p = ev.path
+        if not os.path.isabs(p):
+            if not ev.cwd:
+                return
+            p = os.path.join(ev.cwd, p)
+        p = os.path.normpath(p)
+        self.events += 1
+        bucket = self.by_file[p]
+        for line in ev.added:
+            n = norm(line)
+            if n:
+                bucket[n].append(AgentLine(ev.agent, ev.ts or 0.0))
+
+    def lookup(self, path: str, line: str, committed: float, slack: float = 120) -> str | None:
+        """The agent that wrote this exact line in this file before it was committed, if any."""
+        n = norm(line)
+        if not n:
+            return None
+        hits = self.by_file.get(os.path.normpath(path), {}).get(n)
+        if not hits:
+            return None
+        before = [h for h in hits if h.ts <= committed + slack]
+        return before[-1].agent if before else None
+
+
+@dataclass
+class RepoResult:
+    repo: Path
+    total: int = 0  # substantive lines you shipped in the window that are still in the code
+    by_agent: Counter = field(default_factory=Counter)  # agent -> lines
+    by_month: dict[str, Counter] = field(default_factory=lambda: defaultdict(Counter))  # "2026-03" -> {"you":n, agent:n}
+    files: Counter = field(default_factory=Counter)  # file -> AI lines
+    file_totals: Counter = field(default_factory=Counter)
+    via_logs: int = 0
+    via_trailers: int = 0
+
+    @property
+    def ai(self) -> int:
+        return sum(self.by_agent.values())
+
+
+def blame_file(repo: Path, rel: str):
+    """Yield (sha, author_mail, author_name, author_time, line) for every line at HEAD."""
+    out = git(repo, "blame", "--line-porcelain", "-w", "HEAD", "--", rel)
+    sha = mail = name = None
+    t = 0
+    for line in out.splitlines():
+        if line.startswith("\t"):
+            yield sha, mail, name, t, line[1:]
+            continue
+        head, _, rest = line.partition(" ")
+        if re.fullmatch(r"[0-9a-f]{40}", head):
+            sha = head
+        elif head == "author-mail":
+            mail = rest.strip("<>").lower()
+        elif head == "author":
+            name = rest.lower()
+        elif head == "author-time":
+            t = int(rest)
+
+
+def analyze_repo(repo: Path, me: set[str], since: float, until: float, index: AgentIndex) -> RepoResult:
+    res = RepoResult(repo)
+    if not git(repo, "rev-parse", "--verify", "-q", "HEAD").strip():
+        return res
+    # which commits name an AI tool, and which are by agent bots
+    log = git(repo, "log", "--all", f"--since=@{int(since)}", f"--until=@{int(until)}", "--format=%H%x00%an%x00%ae%x00%B%x1e")
+    ai_commit: dict[str, str] = {}
+    bot_commit: set[str] = set()
+    for rec in log.split("\x1e"):
+        parts = rec.strip("\n").split("\x00")
+        if len(parts) < 4:
+            continue
+        sha, an, ae, body = parts[0], parts[1], parts[2], parts[3]
+        agent = trailer_agent(body)
+        if BOT_AUTHORS.search(f"{an} {ae}"):
+            bot_commit.add(sha)
+            agent = agent or next((k for k, rx in TRAILER_AGENTS if rx.search(f"{an} {ae}")), "copilot")
+        if agent:
+            ai_commit[sha] = agent
+    # files touched in the window that still exist
+    names = git(repo, "log", f"--since=@{int(since)}", f"--until=@{int(until)}", "--name-only", "--format=", "HEAD")
+    tracked = set(git(repo, "ls-files").splitlines())
+    files = sorted({n for n in names.splitlines() if n and n in tracked})
+    for rel in files:
+        if is_generated(rel):
+            continue
+        abspath = str(repo / rel)
+        for sha, mail, name, t, line in blame_file(repo, rel):
+            if not (since <= t <= until) or not norm(line):
+                continue
+            mine = (mail in me or name in me)
+            if not mine and sha not in bot_commit:
+                continue
+            res.total += 1
+            res.file_totals[rel] += 1
+            month = _month(t)
+            agent = index.lookup(abspath, line, t)
+            if agent:
+                res.via_logs += 1
+            elif sha in ai_commit:
+                agent = ai_commit[sha]
+                res.via_trailers += 1
+            if agent:
+                res.by_agent[agent] += 1
+                res.files[rel] += 1
+                res.by_month[month][agent] += 1
+            else:
+                res.by_month[month]["you"] += 1
+    return res
+
+
+GENERATED = re.compile(r"(^|/)(package-lock\.json|yarn\.lock|pnpm-lock\.yaml|poetry\.lock|uv\.lock|Cargo\.lock|"
+                       r"go\.sum|.*\.min\.(js|css)|.*\.map|.*\.svg|.*\.ipynb|.*\.snap|.*\.lock)$|(^|/)(dist|build|vendor|"
+                       r"node_modules|__snapshots__)/")
+
+
+def is_generated(rel: str) -> bool:
+    return bool(GENERATED.search(rel))
+
+
+def _month(t: float) -> str:
+    import time
+    return time.strftime("%Y-%m", time.localtime(t))
+
+
+@dataclass
+class Summary:
+    repos: list[RepoResult]
+    since: float
+    until: float
+    log_events: int = 0
+    agents_seen: Counter = field(default_factory=Counter)
+
+    @property
+    def total(self) -> int:
+        return sum(r.total for r in self.repos)
+
+    @property
+    def by_agent(self) -> Counter:
+        c = Counter()
+        for r in self.repos:
+            c.update(r.by_agent)
+        return Counter(dict(sorted(c.items(), key=lambda kv: (-kv[1], kv[0]))))  # stable order for ties
+
+    @property
+    def ai(self) -> int:
+        return sum(self.by_agent.values())
+
+    @property
+    def share(self) -> float:
+        return self.ai / self.total if self.total else 0.0
+
+    def months(self) -> dict[str, Counter]:
+        out: dict[str, Counter] = defaultdict(Counter)
+        for r in self.repos:
+            for m, c in r.by_month.items():
+                out[m].update(c)
+        return dict(sorted(out.items()))
+
+    def period(self) -> str:
+        import time
+        y0, y1 = time.localtime(self.since).tm_year, time.localtime(self.until).tm_year
+        jan1 = time.mktime((y0, 1, 1, 0, 0, 0, 0, 0, -1))
+        if y0 == y1 and abs(self.since - jan1) < 86400:
+            return f"in {y0}"
+        t = time.localtime(self.since)
+        return f"since {time.strftime('%b', t)} {t.tm_mday}, {t.tm_year}"
+
+    def share_line(self) -> str:
+        top = ", ".join(f"{NAMES.get(a, a)} {n / self.total:.0%}" for a, n in self.by_agent.most_common(3)) \
+            if self.total else ""
+        s = f"{self.share:.0%} of the code I shipped {self.period()} was written by AI"
+        return s + (f" ({top})" if top and self.ai else "") + ". How much of yours? uvx aishare"

aishare-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.5
+Name: aishare
+Version: 0.1.0
+Summary: How much of the code you shipped did AI write? Matches git blame against Claude Code, Codex and Gemini CLI session logs and AI co-author trailers.
+Project-URL: Homepage, https://github.com/ArkaKhorchidian/aishare
+Project-URL: Issues, https://github.com/ArkaKhorchidian/aishare/issues
+Author: Arka Khorchidian
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,claude-code,cli,codex,copilot,developer-tools,gemini-cli,git,git-blame,statistics
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: rich>=13
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+# aishare
+
+**How much of the code you shipped did AI write?** aishare looks at every line git blames on you this year that's still in your code, and works out which ones came from Claude Code, Codex, Gemini CLI, Copilot, Cursor and friends.
+
+```bash
+uvx aishare ~/code
+```
+
+<p align="center"><img src="https://raw.githubusercontent.com/ArkaKhorchidian/aishare/main/docs/demo.gif" alt="aishare demo" width="760"></p>
+
+<sub>Demo on a made-up developer's year (three repos plus agent logs) generated by <a href="docs/demo.py">docs/demo.py</a>. Run it on your own code to get your number.</sub>
+
+## How it knows
+
+Two independent signals, both read locally:
+
+1. **Agent session logs.** Coding agents keep a transcript of every file they write or edit. aishare reads them and records the exact lines each agent produced, per file, and when:
+   - **Claude Code**: `~/.claude/projects/*/*.jsonl` (`Write`, `Edit`, `MultiEdit`)
+   - **Codex CLI**: `~/.codex/sessions/**/rollout-*.jsonl` (`apply_patch`)
+   - **Gemini CLI**: `~/.gemini/tmp/*/chats/session-*` (`write_file`, `replace`)
+
+   Then it runs `git blame` on the files you changed in the period. A line counts as AI-written if an agent wrote that exact line (ignoring whitespace) into that file **before** the commit that introduced it. Lines you wrote earlier that an agent merely re-saved don't count, and lines you later rewrote by hand become yours.
+
+2. **AI co-author trailers.** Commits that say `Co-authored-by: Claude / Copilot / Cursor Agent / Codex / Gemini / Aider / Devin…` or "Generated with Claude Code", plus commits authored by agent bots (Copilot coding agent, Devin, Jules).
+
+Only substantive lines count: blank lines, lone braces and the like are skipped on both sides, and lockfiles, minified files and build output are ignored.
+
+## What it can't see
+
+- **Inline autocomplete** (Copilot, Cursor Tab, Supermaven) leaves no log or trailer, so it's counted as yours. Real numbers are usually higher.
+- **Chat copy-paste** from ChatGPT or Claude.ai in a browser.
+- **Agents that don't keep local logs.** Cursor stores its history in a database, not supported yet.
+
+So treat the result as a floor.
+
+## Options
+
+```
+aishare                          # the repo you're in
+aishare ~/code                   # every repo under a folder
+aishare --since 2026-06          # a different window (YYYY, YYYY-MM or YYYY-MM-DD)
+aishare --email old@work.com     # also count commits under another email
+aishare --json                   # numbers for scripts
+```
+
+It uses your global `git config user.email` and `user.name` to decide which lines are yours.
+
+## Privacy
+
+Everything runs on your machine. aishare reads git and your agents' log files and sends nothing anywhere.
+
+## Install
+
+```bash
+uvx aishare           # run without installing
+pipx install aishare  # or install it
+```
+
+Requires Python 3.9+ and git. The only dependency is `rich`.
+
+## License
+
+MIT

aishare-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+aishare/__init__.py,sha256=KhZhX1KqF3hsiK4B4fRT4AJ8S_p7i5yF5dztnwMv3nI,75
+aishare/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+aishare/agentlogs.py,sha256=KZ-w1mVwluDN0pBELaVm84H_kNJjp83UUwzOHbFRYig,15970
+aishare/cli.py,sha256=E-1nhjvA5pbZdNa-anRNr8mabpNpbQxrTpFXVUVCa4I,7335
+aishare/share.py,sha256=W-N4_pQOQxCBDd6aP5QEabb5YakcdAqOhMEwJgvvrzc,10878
+aishare-0.1.0.dist-info/METADATA,sha256=4uirLHgrfdvTGtCd--C6QPMYfsRqTd3RT96k8MLCeso,3891
+aishare-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+aishare-0.1.0.dist-info/entry_points.txt,sha256=hGBDMPZjCZNi8PejLWWRBD-ixVc7Pm0ZlUG7uq6SPA0,45
+aishare-0.1.0.dist-info/licenses/LICENSE,sha256=mxFQpL6plnvuVMkJNW-M1_rxIlAzORcfDhnP1UETuKI,1073
+aishare-0.1.0.dist-info/RECORD,,

aishare-0.1.0.dist-info/WHEEL

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

aishare-0.1.0.dist-info/entry_points.txt

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

aishare-0.1.0.dist-info/licenses/LICENSE

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