ai-code-stats 0.1.0__py3-none-any.whl

ai_code_stats/classify.py

@@ -0,0 +1,203 @@
+"""文件过滤与行分类。
+
+两个职责，捕获阶段与提交阶段共用：
+
+1. **文件过滤**：决定某个文件是否计入统计（按文件名/类型限制）。
+   - 命中 ``exclude`` glob → 排除。
+   - ``include`` 非空：必须命中某条 include glob 才计入。
+   - ``include`` 为空：仅计入「已知代码语言扩展名」的文件（默认行为，避免把
+     文档/数据/二进制算进代码行）。
+
+2. **行分类**：把新增/删除行分成「全量(raw)」与「有效(effective)」两类。
+   - raw：所有行。
+   - effective：剔除①空行/纯空白行；②纯注释行（按语言注释语法）。
+     块注释在一段连续行内做状态跟踪；未知语言退化为只剔空行。
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import PurePosixPath
+from typing import Any, Dict, List, Optional, Tuple
+
+# 扩展名（小写，含点）→ 语言键。
+EXT_TO_LANG: Dict[str, str] = {
+    ".py": "python", ".pyi": "python",
+    ".js": "clike", ".jsx": "clike", ".mjs": "clike", ".cjs": "clike",
+    ".ts": "clike", ".tsx": "clike",
+    ".java": "clike", ".kt": "clike", ".kts": "clike", ".scala": "clike",
+    ".c": "clike", ".h": "clike", ".cc": "clike", ".cpp": "clike",
+    ".hpp": "clike", ".cxx": "clike", ".hxx": "clike",
+    ".cs": "clike", ".go": "clike", ".rs": "clike", ".swift": "clike",
+    ".php": "clike", ".m": "clike", ".mm": "clike", ".dart": "clike",
+    ".rb": "ruby",
+    ".sh": "hash", ".bash": "hash", ".zsh": "hash", ".fish": "hash",
+    ".yaml": "hash", ".yml": "hash", ".toml": "hash", ".ini": "hash",
+    ".cfg": "hash", ".conf": "hash", ".dockerfile": "hash",
+    ".pl": "hash", ".pm": "hash", ".r": "hash", ".tf": "hash",
+    ".sql": "sql",
+    ".html": "xml", ".htm": "xml", ".xml": "xml", ".vue": "xml",
+    ".svg": "xml",
+    ".css": "block_only", ".scss": "scss", ".less": "scss",
+    ".lua": "lua",
+    ".clj": "lisp", ".cljs": "lisp", ".el": "lisp", ".lisp": "lisp",
+    ".hs": "haskell",
+    ".md": "markdown", ".markdown": "markdown",
+}
+
+# 语言键 → 注释规则：line=行注释前缀，block=块注释 (start,end) 对。
+LANG_RULES: Dict[str, Dict[str, Any]] = {
+    "python": {"line": ["#"], "block": [('"""', '"""'), ("'''", "'''")]},
+    "clike": {"line": ["//"], "block": [("/*", "*/")]},
+    "ruby": {"line": ["#"], "block": [("=begin", "=end")]},
+    "hash": {"line": ["#"], "block": []},
+    "sql": {"line": ["--", "#"], "block": [("/*", "*/")]},
+    "xml": {"line": [], "block": [("<!--", "-->")]},
+    "block_only": {"line": [], "block": [("/*", "*/")]},
+    "scss": {"line": ["//"], "block": [("/*", "*/")]},
+    "lua": {"line": ["--"], "block": [("--[[", "]]")]},
+    "lisp": {"line": [";"], "block": []},
+    "haskell": {"line": ["--"], "block": [("{-", "-}")]},
+    # markdown 没有代码意义上的注释，仅剔空行。
+    "markdown": {"line": [], "block": []},
+}
+
+
+def _glob_to_regex(pattern: str) -> re.Pattern:
+    """把 glob（支持 ``**`` / ``*`` / ``?``）编译成匹配 posix 路径的正则。"""
+    i, n = 0, len(pattern)
+    out = ["(?s:"]
+    while i < n:
+        c = pattern[i]
+        if c == "*":
+            if i + 1 < n and pattern[i + 1] == "*":
+                if i + 2 < n and pattern[i + 2] == "/":
+                    # ``**/`` 表示零或多层目录前缀
+                    i += 3
+                    out.append("(?:.*/)?")
+                else:
+                    # 结尾或非 / 跟随的 ``**`` 匹配任意后缀（含子目录）
+                    i += 2
+                    out.append(".*")
+            else:
+                out.append("[^/]*")
+                i += 1
+        elif c == "?":
+            out.append("[^/]")
+            i += 1
+        else:
+            out.append(re.escape(c))
+            i += 1
+    out.append(")\\Z")
+    return re.compile("".join(out))
+
+
+_GLOB_CACHE: Dict[str, re.Pattern] = {}
+
+
+def _matches_any(path: str, patterns: List[str]) -> bool:
+    posix = PurePosixPath(path).as_posix()
+    base = PurePosixPath(path).name
+    for pat in patterns:
+        rx = _GLOB_CACHE.get(pat)
+        if rx is None:
+            rx = _glob_to_regex(pat)
+            _GLOB_CACHE[pat] = rx
+        # 既匹配完整相对路径，也匹配纯文件名（方便写 "yarn.lock" 这类）。
+        if rx.match(posix) or rx.match(base):
+            return True
+    return False
+
+
+class Classifier:
+    """绑定一份配置的过滤/分类器。"""
+
+    def __init__(self, files_config: Optional[Dict[str, Any]] = None,
+                 comment_rules_override: Optional[Dict[str, Any]] = None):
+        files_config = files_config or {}
+        self.include: List[str] = list(files_config.get("include", []) or [])
+        self.exclude: List[str] = list(files_config.get("exclude", []) or [])
+        self.ext_override: Dict[str, str] = dict(files_config.get("language_extensions", {}) or {})
+        self.comment_override: Dict[str, Any] = dict(comment_rules_override or {})
+
+    # ---- 文件过滤 ----------------------------------------------------
+    def language_for(self, path: str) -> Optional[str]:
+        name = PurePosixPath(path).name.lower()
+        # 先看完整文件名特例（如 Dockerfile / Makefile）。
+        if name in ("dockerfile",):
+            return "hash"
+        if name in ("makefile",):
+            return "hash"
+        ext = PurePosixPath(path).suffix.lower()
+        if ext in self.ext_override:
+            return self.ext_override[ext]
+        return EXT_TO_LANG.get(ext)
+
+    def is_included(self, path: str) -> bool:
+        if _matches_any(path, self.exclude):
+            return False
+        if self.include:
+            return _matches_any(path, self.include)
+        # include 为空：默认只计已知代码语言文件。
+        return self.language_for(path) is not None
+
+    # ---- 行分类 ------------------------------------------------------
+    def _rules(self, language: Optional[str]) -> Dict[str, Any]:
+        if language and language in self.comment_override:
+            return self.comment_override[language]
+        return LANG_RULES.get(language or "", {"line": [], "block": []})
+
+    def classify_lines(self, lines: List[str], path: str) -> List[bool]:
+        """返回每行的 is_effective 列表。``lines`` 应是一段连续行（如一个 hunk）。"""
+        language = self.language_for(path)
+        rules = self._rules(language)
+        line_prefixes: List[str] = rules.get("line", [])
+        blocks: List[Tuple[str, str]] = [tuple(b) for b in rules.get("block", [])]
+
+        result: List[bool] = []
+        in_block_end: Optional[str] = None  # 当前所处块注释的结束符
+        for raw in lines:
+            stripped = raw.strip()
+            if in_block_end is not None:
+                # 处于块注释中：查找结束符。
+                idx = stripped.find(in_block_end)
+                if idx >= 0:
+                    after = stripped[idx + len(in_block_end):].strip()
+                    in_block_end = None
+                    result.append(bool(after))  # 结束符后还有代码才算有效
+                else:
+                    result.append(False)
+                continue
+
+            if not stripped:
+                result.append(False)
+                continue
+
+            # 行注释：整行以注释前缀开头 → 非有效。
+            if any(stripped.startswith(p) for p in line_prefixes):
+                result.append(False)
+                continue
+
+            # 块注释起始。
+            matched_block = False
+            for start, end in blocks:
+                if stripped.startswith(start):
+                    rest = stripped[len(start):]
+                    end_idx = rest.find(end)
+                    if end_idx >= 0:
+                        after = rest[end_idx + len(end):].strip()
+                        result.append(bool(after))  # 单行块注释，后有代码才有效
+                    else:
+                        in_block_end = end
+                        result.append(False)
+                    matched_block = True
+                    break
+            if matched_block:
+                continue
+
+            result.append(True)
+        return result
+
+    def is_effective_line(self, line: str, path: str) -> bool:
+        """单行判定（无跨行块注释状态），用于捕获阶段逐行打标。"""
+        return self.classify_lines([line], path)[0]

ai_code_stats/cli.py

@@ -0,0 +1,216 @@
+"""ai-code-stats 命令行入口。
+
+子命令：
+    install / uninstall   安装、卸载 git 与 Agent 钩子
+    hook                  Agent 钩子被调用时的入口（读 stdin JSON）
+    githook               git 钩子入口（post-commit）
+    report                打印当前 HEAD 的统计信封（不发送、不消费）
+    status                查看待归因事件与 token 快照
+    flush                 重试发送失败队列
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from . import __version__
+from . import config as config_mod
+from . import paths as paths_mod
+
+
+# ---- pythonpath 自动探测（开发/源码运行时需要）-------------------------
+def _default_pythonpath() -> Optional[str]:
+    import ai_code_stats
+
+    pkg_parent = Path(ai_code_stats.__file__).resolve().parents[1]
+    if "site-packages" in str(pkg_parent) or "dist-packages" in str(pkg_parent):
+        return None  # 已正常安装，无需注入
+    return str(pkg_parent)
+
+
+def _repo_root_or_exit(explicit: Optional[str]) -> Path:
+    from .gitutil import repo_root
+
+    start = Path(explicit) if explicit else Path.cwd()
+    root = repo_root(start)
+    if root is None:
+        print("错误：当前不在 git 仓库内", file=sys.stderr)
+        sys.exit(2)
+    return root
+
+
+# ---- install / uninstall ----------------------------------------------
+def cmd_install(args: argparse.Namespace) -> int:
+    from .install import agent_install, git_install
+
+    python_exe = sys.executable
+    pythonpath = args.pythonpath or _default_pythonpath()
+    targets = _resolve_targets(args)
+    repo_root = None
+    if "git" in targets or (("claude" in targets) and args.scope == "project"):
+        repo_root = _repo_root_or_exit(args.repo)
+
+    msgs: List[str] = []
+    if "git" in targets:
+        msgs.append("[git] " + git_install.install(repo_root, python_exe, pythonpath, args.dry_run))
+    if "claude" in targets:
+        msgs.append("[claude] " + agent_install.install_claude(
+            repo_root, python_exe, scope=args.scope, pythonpath=pythonpath, dry_run=args.dry_run))
+    if "codex" in targets:
+        msgs.append("[codex] " + agent_install.install_codex(python_exe, pythonpath, args.dry_run))
+    print("\n".join(msgs))
+    return 0
+
+
+def cmd_uninstall(args: argparse.Namespace) -> int:
+    from .install import agent_install, git_install
+
+    targets = _resolve_targets(args)
+    repo_root = None
+    if "git" in targets or (("claude" in targets) and args.scope == "project"):
+        repo_root = _repo_root_or_exit(args.repo)
+    msgs: List[str] = []
+    if "git" in targets:
+        msgs.append("[git] " + git_install.uninstall(repo_root))
+    if "claude" in targets:
+        msgs.append("[claude] " + agent_install.uninstall_claude(repo_root, scope=args.scope))
+    if "codex" in targets:
+        msgs.append("[codex] " + agent_install.uninstall_codex())
+    print("\n".join(msgs))
+    return 0
+
+
+def _resolve_targets(args: argparse.Namespace) -> List[str]:
+    chosen = [t for t in ("git", "claude", "codex") if getattr(args, t)]
+    return chosen if chosen else ["git", "claude", "codex"]
+
+
+# ---- hook / githook ----------------------------------------------------
+def cmd_hook(args: argparse.Namespace) -> int:
+    from .hooks import session_event, tool_event
+
+    try:
+        raw = sys.stdin.read()
+        payload = json.loads(raw) if raw.strip() else {}
+    except json.JSONDecodeError:
+        return 0  # 钩子静默失败
+    if not isinstance(payload, dict):
+        return 0
+
+    event = (args.event or "").lower()
+    if event in ("stop", "session_end", "sessionend", "session_start", "sessionstart"):
+        return session_event.process(args.agent, payload)
+    return tool_event.process(args.agent, payload)
+
+
+def cmd_githook(args: argparse.Namespace) -> int:
+    from .githook import post_commit
+
+    return post_commit.process(dry_run=args.dry_run)
+
+
+# ---- report / status / flush ------------------------------------------
+def cmd_report(args: argparse.Namespace) -> int:
+    from .githook import post_commit
+
+    _repo_root_or_exit(args.repo)
+    return post_commit.process(cwd=Path(args.repo) if args.repo else None, dry_run=True)
+
+
+def cmd_status(args: argparse.Namespace) -> int:
+    from .storage import Storage
+
+    root = _repo_root_or_exit(args.repo)
+    cfg = config_mod.load_config(root)
+    storage = Storage(root)
+    pending = storage.read_pending()
+    snaps = storage.load_token_snapshots()
+
+    by_agent: dict = {}
+    ai_lines = 0
+    for ev in pending:
+        by_agent[ev.get("agent", "?")] = by_agent.get(ev.get("agent", "?"), 0) + 1
+        ai_lines += len(ev.get("added_lines", []))
+
+    print(f"仓库数据目录: {storage.dir}")
+    print(f"启用状态: {cfg.enabled}")
+    print(f"待归因 AI 事件: {len(pending)} 条，累计 {ai_lines} 行")
+    for agent, n in sorted(by_agent.items()):
+        print(f"  - {agent}: {n} 条")
+    print(f"已知 session token 快照: {len(snaps)} 个")
+    for sid, entry in snaps.items():
+        cum = entry.get("cumulative", {})
+        print(f"  - {sid[:12]} [{entry.get('agent','')}] 累计 in={cum.get('input',0)} out={cum.get('output',0)}")
+    return 0
+
+
+def cmd_flush(args: argparse.Namespace) -> int:
+    from .reporters import registry
+    from .reporters.base import ReporterContext
+
+    ctx = ReporterContext(repo_data_dir=str(paths_mod.user_data_dir()))
+    succeeded, remaining = registry.flush_retries(ctx)
+    print(f"重试成功 {succeeded} 条，剩余 {remaining} 条")
+    return 0
+
+
+# ---- 解析器 ------------------------------------------------------------
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(prog="ai-code-stats", description="AI 代码采纳率与 token 统计插件")
+    p.add_argument("--version", action="version", version=f"ai-code-stats {__version__}")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    def add_targets(sp):
+        sp.add_argument("--git", action="store_true", help="只针对 git 钩子")
+        sp.add_argument("--claude", action="store_true", help="只针对 Claude Code")
+        sp.add_argument("--codex", action="store_true", help="只针对 Codex")
+        sp.add_argument("--scope", choices=["project", "user"], default="project",
+                        help="Claude settings 作用域（默认 project）")
+        sp.add_argument("--repo", help="仓库路径（默认当前目录）")
+        sp.add_argument("--pythonpath", help="注入钩子命令的 PYTHONPATH（开发用）")
+
+    sp_i = sub.add_parser("install", help="安装钩子")
+    add_targets(sp_i)
+    sp_i.add_argument("--dry-run", action="store_true", help="只预览不写入")
+    sp_i.set_defaults(func=cmd_install)
+
+    sp_u = sub.add_parser("uninstall", help="卸载钩子")
+    add_targets(sp_u)
+    sp_u.set_defaults(func=cmd_uninstall)
+
+    sp_h = sub.add_parser("hook", help="Agent 钩子入口（读 stdin）")
+    sp_h.add_argument("--agent", required=True, help="claude_code | codex")
+    sp_h.add_argument("--event", help="事件名（如 stop）")
+    sp_h.set_defaults(func=cmd_hook)
+
+    sp_g = sub.add_parser("githook", help="git 钩子入口")
+    sp_g.add_argument("kind", nargs="?", default="post-commit", help="钩子类型（post-commit）")
+    sp_g.add_argument("--dry-run", action="store_true", help="打印信封不发送")
+    sp_g.set_defaults(func=cmd_githook)
+
+    sp_r = sub.add_parser("report", help="打印当前 HEAD 的统计信封（不发送）")
+    sp_r.add_argument("--repo", help="仓库路径")
+    sp_r.set_defaults(func=cmd_report)
+
+    sp_s = sub.add_parser("status", help="查看待归因事件与 token 快照")
+    sp_s.add_argument("--repo", help="仓库路径")
+    sp_s.set_defaults(func=cmd_status)
+
+    sp_f = sub.add_parser("flush", help="重试失败的上报队列")
+    sp_f.set_defaults(func=cmd_flush)
+
+    return p
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ai_code_stats/config.py

@@ -0,0 +1,171 @@
+"""配置加载与合并。
+
+解析顺序（后者覆盖前者，逐键深合并）：
+    1. 内置默认值（``DEFAULT_CONFIG``）
+    2. 用户级配置文件（``paths.user_config_file()``）
+    3. 仓库级配置文件（``<repo>/.ai-code-stats.json``）
+    4. ``AI_CODE_STATS_CONFIG`` 环境变量指向的文件
+
+字符串值支持 ``${ENV:VAR}`` 占位插值，用于在 header 等处注入密钥，避免明文落盘。
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import os
+import re
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from . import paths
+
+REPO_CONFIG_FILENAME = ".ai-code-stats.json"
+
+DEFAULT_CONFIG: Dict[str, Any] = {
+    "enabled": True,
+    "privacy": {
+        # 本地是否保留 AI 行明文（关闭则只存哈希；用户已选择明文+哈希）。
+        "store_plaintext": True,
+        # 上报载荷是否脱敏（默认 true：上报只含统计数字，不含源码明文）。
+        "redact_in_reports": True,
+    },
+    "files": {
+        # 为空表示「全部代码文件」；非空则只统计匹配 include 的文件。
+        "include": [],
+        # 排除项优先级高于 include。
+        "exclude": [
+            "**/node_modules/**",
+            "**/vendor/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.venv/**",
+            "**/*.min.js",
+            "**/*.min.css",
+            "package-lock.json",
+            "**/package-lock.json",
+            "yarn.lock",
+            "**/yarn.lock",
+            "pnpm-lock.yaml",
+            "**/pnpm-lock.yaml",
+            "poetry.lock",
+            "**/poetry.lock",
+            "Cargo.lock",
+            "**/Cargo.lock",
+            "go.sum",
+            "**/go.sum",
+        ],
+        # 额外的扩展名→语言映射覆盖（合并进 classify 内置表）。
+        "language_extensions": {},
+    },
+    "attribution": {
+        # 行归一化方式："strip"=去首尾空白后哈希。
+        "normalize": "strip",
+        # 短于该长度（归一化后）的行不参与 AI 指纹匹配，降低误命中。
+        "min_line_length": 1,
+        # 输出口径。
+        "count_modes": ["raw", "effective"],
+        "primary": "effective",
+        # 行分类注释规则覆盖：{ "lang": {"line": ["//"], "block": [["/*","*/"]]} }
+        "comment_rules": {},
+        # merge 提交处理："skip"=仅记 totals 不算采纳率；"first_parent"=对 first-parent diff 统计。
+        "merge_strategy": "skip",
+        "detect_renames": True,
+        "detect_copies": False,
+    },
+    # 启用的 Agent 适配器。
+    "agents": ["claude_code", "codex"],
+    # 上报后端列表，按序派发。
+    "reporters": [
+        {"type": "json_file", "path": "{repo_data}/reports.jsonl"},
+    ],
+}
+
+_ENV_PATTERN = re.compile(r"\$\{ENV:([A-Za-z_][A-Za-z0-9_]*)\}")
+
+
+def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
+    """递归合并 override 进 base（返回新 dict，不改原对象）。
+
+    dict 逐键合并；其余类型（含 list）整体覆盖。
+    """
+    result = copy.deepcopy(base)
+    for key, value in override.items():
+        if (
+            key in result
+            and isinstance(result[key], dict)
+            and isinstance(value, dict)
+        ):
+            result[key] = _deep_merge(result[key], value)
+        else:
+            result[key] = copy.deepcopy(value)
+    return result
+
+
+def _load_json_file(path: Path) -> Dict[str, Any]:
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except FileNotFoundError:
+        return {}
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ConfigError(f"无法解析配置文件 {path}: {exc}") from exc
+    if not isinstance(data, dict):
+        raise ConfigError(f"配置文件 {path} 顶层必须是 JSON 对象")
+    return data
+
+
+def interpolate_env(value: Any) -> Any:
+    """递归把字符串里的 ``${ENV:VAR}`` 替换为环境变量值（缺失则替换为空串）。"""
+    if isinstance(value, str):
+        return _ENV_PATTERN.sub(lambda m: os.environ.get(m.group(1), ""), value)
+    if isinstance(value, list):
+        return [interpolate_env(v) for v in value]
+    if isinstance(value, dict):
+        return {k: interpolate_env(v) for k, v in value.items()}
+    return value
+
+
+class ConfigError(Exception):
+    """配置解析/校验错误。"""
+
+
+class Config:
+    """已合并的配置视图，提供按点路径取值的便捷方法。"""
+
+    def __init__(self, data: Dict[str, Any]):
+        self.data = data
+
+    def get(self, dotted: str, default: Any = None) -> Any:
+        node: Any = self.data
+        for part in dotted.split("."):
+            if isinstance(node, dict) and part in node:
+                node = node[part]
+            else:
+                return default
+        return node
+
+    @property
+    def enabled(self) -> bool:
+        return bool(self.data.get("enabled", True))
+
+    def __repr__(self) -> str:  # pragma: no cover - 调试用
+        return f"Config({json.dumps(self.data, ensure_ascii=False)})"
+
+
+def load_config(repo_root: Optional[Path] = None) -> Config:
+    """加载并合并配置。``repo_root`` 提供时叠加仓库级配置。"""
+    merged = copy.deepcopy(DEFAULT_CONFIG)
+
+    user_file = paths.user_config_file()
+    merged = _deep_merge(merged, _load_json_file(user_file))
+
+    if repo_root is not None:
+        repo_file = Path(repo_root) / REPO_CONFIG_FILENAME
+        merged = _deep_merge(merged, _load_json_file(repo_file))
+
+    env_file = os.environ.get("AI_CODE_STATS_CONFIG")
+    if env_file:
+        merged = _deep_merge(merged, _load_json_file(Path(env_file).expanduser()))
+
+    return Config(merged)

ai_code_stats/diffutil.py

@@ -0,0 +1,96 @@
+"""从字符串编辑或补丁文本中提取「新增行 / 删除行」。
+
+支持三类输入：
+- 字符串前后对比（Claude 的 Edit/MultiEdit：old_string → new_string）。
+- git 统一 diff（``--- / +++ / @@`` 三联）。
+- Codex / OpenAI ``apply_patch`` 信封（``*** Begin Patch`` ... ``*** End Patch``）。
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Tuple
+
+
+@dataclass
+class PatchedFile:
+    path: str
+    added: List[str] = field(default_factory=list)
+    removed: List[str] = field(default_factory=list)
+
+
+def added_lines_between(old: str, new: str) -> Tuple[List[str], List[str]]:
+    """对比两段文本，返回 (新增行, 删除行)，忽略未变化的上下文行。"""
+    old_lines = old.splitlines()
+    new_lines = new.splitlines()
+    sm = difflib.SequenceMatcher(a=old_lines, b=new_lines, autojunk=False)
+    added: List[str] = []
+    removed: List[str] = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag in ("insert", "replace"):
+            added.extend(new_lines[j1:j2])
+        if tag in ("delete", "replace"):
+            removed.extend(old_lines[i1:i2])
+    return added, removed
+
+
+_DIFF_FILE_RE = re.compile(r"^\+\+\+ (?:b/)?(.+?)\s*$")
+
+
+def parse_unified_diff(diff: str) -> List[PatchedFile]:
+    files: List[PatchedFile] = []
+    current: PatchedFile | None = None
+    for line in diff.splitlines():
+        m = _DIFF_FILE_RE.match(line)
+        if m:
+            path = m.group(1)
+            if path == "/dev/null":
+                path = ""
+            current = PatchedFile(path=path)
+            files.append(current)
+            continue
+        if current is None:
+            continue
+        if line.startswith("+++") or line.startswith("---") or line.startswith("@@"):
+            continue
+        if line.startswith("+"):
+            current.added.append(line[1:])
+        elif line.startswith("-"):
+            current.removed.append(line[1:])
+    return [f for f in files if f.path]
+
+
+_APPLY_HEADER_RE = re.compile(r"^\*\*\* (Add|Update|Delete) File: (.+?)\s*$")
+
+
+def parse_apply_patch(patch: str) -> List[PatchedFile]:
+    """解析 OpenAI/Codex apply_patch 信封。"""
+    files: List[PatchedFile] = []
+    current: PatchedFile | None = None
+    for line in patch.splitlines():
+        if line.startswith("*** Begin Patch") or line.startswith("*** End Patch"):
+            continue
+        m = _APPLY_HEADER_RE.match(line)
+        if m:
+            current = PatchedFile(path=m.group(2))
+            files.append(current)
+            continue
+        if current is None:
+            continue
+        if line.startswith("@@"):
+            continue
+        if line.startswith("+"):
+            current.added.append(line[1:])
+        elif line.startswith("-"):
+            current.removed.append(line[1:])
+        # 以空格开头的上下文行与 "*** Move to:" 等其它指令忽略
+    return [f for f in files if f.path]
+
+
+def parse_patch(text: str) -> List[PatchedFile]:
+    """自动识别补丁类型并解析。"""
+    if "*** Begin Patch" in text or _APPLY_HEADER_RE.search(text or ""):
+        return parse_apply_patch(text)
+    return parse_unified_diff(text)

ai_code_stats/githook/__init__.py

@@ -0,0 +1 @@
+"""git 钩子入口（post-commit）：在每次提交时计算并上报统计。"""