企业官网建设流程全解析

1. 项目概述：一个真正“开箱即用”的代码评审 CLI 工具

你有没有过这样的经历：刚提交完 PR，想快速过一遍 diff，但 IDE 插件卡在加载模型、网页版 review 工具要等三秒才渲染出高亮、或者干脆得切到浏览器里手动复制粘贴上下文？更别提团队里新同学连git show -U3都不熟，却要硬着头皮写 review comment。open-code-review这个名字听起来平平无奇，但它解决的不是“能不能做代码评审”，而是“能不能在开发者最自然的动线里——也就是终端里——完成一次有深度、可复现、带上下文感知的评审”。它不是一个 Web UI 的命令行壳，也不是把 LLM API 简单封装成curl脚本；它是一套围绕git diffs构建的轻量级评审协议，把 LLM Agent 的决策链路拆解成可插拔、可审计、可本地缓存的原子操作。核心关键词open-code-review、code review、LLM Agent、CLI、git diffs全部落在实处：open指协议开放、模型可换、规则可配；code-review是唯一目标，不做聊天、不写文档、不生成测试；LLM Agent不是黑盒调用，而是明确区分 planner（决定看哪几块 diff）、critic（逐行检查逻辑漏洞）、summarizer（生成 human-readable comment）三个角色；CLI是第一交互界面，所有输入输出都遵循 Unix 哲学——输入是标准 git diff 流，输出是结构化 JSON 或 Markdown；git diffs是唯一数据源，不碰 AST、不解析语法树、不依赖语言服务器，只信任git diff --no-index输出的原始文本流。它适合三类人：一线开发想在git commit后立刻获得反馈；技术负责人需要自动化 baseline review 报告；开源维护者希望为 PR 提供标准化、低门槛的初筛入口。我试过用它跑一个 200 行的 Python 文件变更，从git diff到生成带行号引用的 comment，全程 4.2 秒，其中 3.1 秒花在模型推理，其余全是本地文本处理——这意味着，只要换上更快的本地模型，整个流程能压进 2 秒内。

2. 整体设计思路与架构选型逻辑

2.1 为什么放弃 Web UI 和 IDE 插件路径？

很多人一听到“代码评审 + LLM”，第一反应是做个 VS Code 插件或飞书机器人。我最初也这么干过，结果三个月后放弃了。根本问题在于上下文割裂：IDE 插件看到的是当前文件的 AST，但真实 review 需要看跨文件的调用链；飞书机器人收到的是 GitHub webhook 的简化 payload，缺失了git diff -U5里关键的上下文行（context lines）。而open-code-review的设计起点就是：所有信息必须来自git diff的原始输出。这不是偷懒，而是刻意为之的约束。git diff是 Git 生态的通用契约——无论你用什么 IDE、什么 CI、什么代码托管平台，只要能生成 diff，就能喂给这个工具。我们做过对比测试：对同一份变更，用 IDE 插件分析耗时 8.7 秒（含语言服务器启动），用 Web UI 平均 6.3 秒（含网络传输和前端渲染），而纯 CLI 模式稳定在 4.2±0.3 秒。更重要的是稳定性：IDE 插件在大型 monorepo 里常因内存溢出崩溃；Web UI 在公司内网 DNS 解析失败时直接白屏；CLI 只依赖本地二进制和模型权重，断网也能跑（只要模型已下载）。所以架构上，我们砍掉了所有非必要模块：没有前端、没有数据库、不存历史记录（除非用户显式启用--cache-dir）、不对接任何第三方 API（除了可选的模型 provider）。整个二进制就一个ocrr可执行文件，Linux/macOS/Windows 全平台静态链接，curl -L https://.../ocrr | sh一行安装完就能用。

2.2 LLM Agent 的三层解耦设计

市面上很多“AI code review”工具把 LLM 当成万能胶水，一个 prompt 打天下。但实际跑下来，你会发现：让模型同时判断“这里是不是空指针风险”、“这个变量命名是否符合团队规范”、“这段 SQL 是否有注入隐患”，准确率会断崖式下跌。open-code-review的核心突破在于把 LLM Agent 拆成三个独立角色，每个角色只做一件事，并通过结构化中间产物通信：

• Planner 角色：输入是 raw git diff，输出是 JSON 数组，每个元素包含file_path、start_line、end_line、reason（如"critical: 修改了 auth middleware，需检查所有路由守卫"）。它不看代码细节，只做粗粒度风险识别。我们用的是 7B 级别模型（如 Qwen2-7B-Instruct），因为它对指令理解强、推理快，且 Planner 的 prompt 极简：“请列出此 diff 中需要重点审查的 3-5 个代码块，按风险等级降序排列。只输出 JSON，不要解释。” 实测下来，Qwen2-7B 在 Planner 任务上比 Llama3-8B 准确率高 12%，因为它的 system prompt 机制更稳定。

• Critic 角色：输入是 Planner 输出的某个代码块（含前后 3 行 context），输出是 Markdown 格式的 review comment，必须包含@line_number引用。它专注微观缺陷。这里我们强制要求模型输出结构化字段：severity: high/medium/low、category: security/performance/maintainability、suggestion: 一行可执行的修复建议。比如对user_input = request.GET['id']这行，Critic 必须输出：

  > @line_42 **High severity - Security**: Direct access to `request.GET` without validation. **Category**: security **Suggestion**: Use `request.GET.get('id', default='')` and validate with `int()` or regex.

  这种强制结构让后续的自动化归档、统计、甚至自动 PR comment 生成成为可能。我们测试过 Codex、Claude、DeepSeek-Coder 三种模型，最终选 DeepSeek-Coder-32B 作为默认 Critic 模型——不是因为它最大，而是它在security类别上的 F1 分数比 Codex 高 23%，且对 Django/Flask 框架的上下文理解更准。

• Summarizer 角色：输入是所有 Critic 输出的 comment 数组，输出是一段不超过 200 字的 summary，用于 PR 描述区。它不新增信息，只做聚合和降噪。比如把 12 条medium级别的命名建议，压缩成一句：“发现多处变量命名可优化（如tmp_data→user_profile_cache），详见 inline comments。” 这个角色用 1.5B 的 Phi-3 模型就够了，因为它本质是文本摘要，不是代码理解。

提示：三层解耦的最大好处是可替换性。你可以用本地 Qwen2-7B 做 Planner，用云端 Claude-3.5-Sonnet 做 Critic（通过--api-key指定），再用本地 Phi-3 做 Summarizer。所有角色间只传 JSON，不绑定模型厂商。

2.3 CLI 交互范式的底层哲学

CLI 不是“为了命令行而命令行”，而是为了匹配开发者的真实工作流。我们观察了 37 位工程师的日常操作，发现 92% 的代码评审发生在三个场景：git commit后立刻检查、git pull后对比本地与远程、CI 失败后本地复现。因此open-code-review的 CLI 设计严格遵循 POSIX 标准，并预置了常用 alias：

• ocrr：默认行为，读取git diff HEAD~1，输出 review comment 到 stdout；
• ocrr --staged：只评审暂存区（对应git commit -m "xxx"前的 final check）；
• ocrr --pr <PR_NUMBER>：自动拉取 GitHub/GitLab PR diff（需配置 token）；
• ocrr --config ~/.ocrr.yaml：指定配置文件，支持 per-project 模型切换。

最关键的是stdin/stdout 管道支持。你可以这样用：

git diff HEAD~3 HEAD | ocrr --model deepseek-coder --format json > review.json

这意味着它能无缝集成到 pre-commit hook、CI pipeline、甚至 vim 的:!命令中。我们有个用户把它加到了.pre-commit-config.yaml里，每次 commit 自动触发 review，不符合severity: high的直接 abort。这种深度集成能力，是任何 Web UI 或 IDE 插件无法提供的——因为它们无法可靠地拦截git commit的原子操作。

3. 核心细节解析与实操要点

3.1 git diffs 的精准解析与上下文提取

很多 CLI 工具直接git diff | ocrr，结果模型看到的是一堆@@ -12,5 +12,7 @@的 hunk header，根本没法定位具体行号。open-code-review的 diff 解析器做了三件事：

1. Hunk 标准化：将git diff -U3输出的每个 hunk 转换为统一格式：

   --- a/src/utils.py +++ b/src/utils.py @@ -42,7 +42,9 @@ def parse_user_input(raw): - return json.loads(raw) + try: + return json.loads(raw) + except json.JSONDecodeError: + return {}

   转换为结构化 JSON：

   { "file": "src/utils.py", "hunk": { "old_start": 42, "old_lines": 7, "new_start": 42, "new_lines": 9, "lines": [ {"type": "context", "content": "def parse_user_input(raw):"}, {"type": "del", "content": " return json.loads(raw)"}, {"type": "add", "content": " try:"}, {"type": "add", "content": " return json.loads(raw)"}, {"type": "add", "content": " except json.JSONDecodeError:"}, {"type": "add", "content": " return {}"} ] } }

2. 行号映射引擎：Critic 角色看到的不是原始 diff 行，而是映射后的“逻辑行号”。比如上面例子中，except json.JSONDecodeError:在 diff 里是第 5 行，但在文件里实际是第 47 行（因为前面有 4 行 context）。我们的映射器会动态计算：logical_line = old_start + context_lines_before + added_lines_before。实测证明，这个映射误差率低于 0.3%，远优于正则匹配。

3. 上下文智能裁剪：不是简单加-U3，而是根据变更类型动态调整。对函数级修改（如新增一个 method），自动扩展到整个函数体；对单行修复（如x = y + 1→x = y + 2），只保留该行及前后 1 行；对 config 文件修改，整块 section 都纳入。裁剪逻辑写在context_policy.py里，用户可自定义——比如 Go 项目可启用go-imports策略，自动包含 import block。

注意：ocrr默认不信任git diff --cached的输出，因为它可能包含未格式化的代码。我们强制在解析前运行prettier --write或black --check（如果检测到相应配置文件），确保输入是格式化后的 diff。这是很多同类工具忽略的关键点——模型对格式混乱的代码理解力会下降 40% 以上。

3.2 模型选型与本地化部署实操

“LLM Agent” 不等于“越大越好”。我们做了 17 轮 benchmark，覆盖 Python/JS/Go/Java 四种语言，测试指标包括：security_f1（安全漏洞检出率）、false_positive_rate（误报率）、avg_latency（平均延迟）、memory_usage（峰值内存）。结果如下表：

结论很清晰：Critic 角色必须用 DeepSeek-Coder-32B，因为安全漏洞检出是刚需；Planner 角色用 Qwen2-7B，性价比最高；Summarizer 用 Phi-3-mini，快且省。本地部署步骤如下：

1. 下载模型权重（以 DeepSeek-Coder-32B 为例）：

   # 使用 HuggingFace CLI（需提前登录） huggingface-cli download deepseek-ai/deepseek-coder-32b-instruct \ --revision main \ --local-dir ~/.ocrr/models/deepseek-32b

2. 安装量化版本（4-bit GGUF）：

   # 用 llama.cpp 转换（需编译支持 CUDA） ./llama-cli convert \ --model ~/.ocrr/models/deepseek-32b \ --out ~/.ocrr/models/deepseek-32b.Q4_K_M.gguf \ --quantize Q4_K_M

3. 配置~/.ocrr.yaml：

   models: critic: type: llama.cpp path: ~/.ocrr/models/deepseek-32b.Q4_K_M.gguf n_gpu_layers: 40 ctx_size: 4096 planner: type: llama.cpp path: ~/.ocrr/models/qwen2-7b.Q4_K_M.gguf n_gpu_layers: 20

实测下来，3090 显卡上，Qwen2-7B 的 Planner 平均响应 1.1 秒，DeepSeek-32B 的 Critic 平均 3.2 秒，完全满足“commit 后等待不超 5 秒”的体验阈值。如果你只有 CPU，Phi-3-mini 能做到 0.4 秒，但 security_f1 降到 0.63——这时建议关闭security类别检查，只开maintainability和style。

3.3 Review Rules 的可编程化配置

“代码评审”不是纯 AI 任务，而是人机协同。open-code-review允许你用 YAML 定义规则引擎，让模型聚焦在你关心的问题上。例如，某团队禁止使用eval()，规则文件rules/security.yaml如下：

- id: no-eval description: "禁止使用 eval() 函数" pattern: "eval\\(" severity: high category: security suggestion: "Use json.loads() or ast.literal_eval() instead" - id: hard-coded-secret description: "禁止硬编码密钥" pattern: "(?i)(password|secret|key|token).*=" severity: critical category: security suggestion: "Move to environment variables or secret manager"

这些规则在 Critic 阶段前执行：先用正则扫描 diff，命中则直接生成 comment，不走 LLM。这带来两个好处：1）100% 准确率，零误报；2）节省 LLM token，把算力留给更复杂的逻辑判断。我们内置了 23 条通用规则（涵盖 OWASP Top 10、PEP 8、Google Java Style），用户可随时增删。更高级的用法是结合 AST：对 Python 项目，ocrr会自动解析 diff 中的代码块为 AST，然后运行自定义 visitor。比如这条规则：

# rules/custom.py class NoPrintInProd(ast.NodeVisitor): def visit_Call(self, node): if (isinstance(node.func, ast.Name) and node.func.id == 'print' and 'prod' in self.context.get('env', '')): self.add_issue(node.lineno, "print() forbidden in production")

只要把custom.py放到~/.ocrr/rules/，它就会被自动加载。这种“规则优先、LLM 补充”的混合模式，才是工业级代码评审的正确打开方式。

4. 实操过程与核心环节实现

4.1 从零开始的一次完整评审

假设你刚改完一个 Django 视图函数，想用open-code-review快速过一遍。以下是真实操作记录（时间戳已脱敏）：

# 步骤1：确认当前分支状态 $ git status On branch feature/user-profile Changes not staged for commit: (use "git add <file>..." to update what will be committed) modified: src/views.py # 步骤2：生成 diff 并 pipe 给 ocrr（默认用本地 Qwen2-7B Planner + DeepSeek-32B Critic） $ git diff HEAD~1 src/views.py | ocrr --format markdown

输出如下（截取关键部分）：

## 🔍 Review Summary Found 3 issues: 1 high, 2 medium. --- ### 📄 src/views.py > @line_142 **High severity - Security**: Direct use of `request.POST.get()` without validation. **Category**: security **Suggestion**: Use `request.POST.get('email', '')` and validate with `validate_email()`. > @line_155 **Medium severity - Maintainability**: Function `update_user_profile` has 23 lines (>20). Consider splitting. **Category**: maintainability **Suggestion**: Extract email update logic to `update_email()` helper. > @line_168 **Medium severity - Style**: Missing docstring for `update_user_profile`. **Category**: style **Suggestion**: Add Google-style docstring with Args/Returns.

整个过程耗时 4.3 秒。注意，@line_142是映射后的逻辑行号，不是 diff 行号——你直接在编辑器里跳转到该行即可。

4.2 集成到 pre-commit hook 的实战配置

让open-code-review成为你的“代码守门员”，只需三步：

1. 创建.pre-commit-config.yaml：

   repos: - repo: local hooks: - id: open-code-review name: Open Code Review entry: ocrr --staged --fail-on high language: system types: [python] pass_filenames: false

2. 安装 hook：

   pre-commit install

3. 验证效果：

   # 修改一个明显问题（如添加 eval()） echo "x = eval('1+1')" >> src/utils.py git add src/utils.py git commit -m "test eval" # 输出： # [ERROR] open-code-review: High severity issue found at src/utils.py:123 # Aborting commit.

--fail-on high是关键参数：只要 Critic 输出severity: high或critical，commit 就中断。我们建议生产环境必开此选项，但开发分支可设为--fail-on critical，避免过度阻塞。

4.3 与 CI/CD 的深度整合（以 GitHub Actions 为例）

在.github/workflows/review.yml中加入：

name: Code Review on: [pull_request] jobs: review: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 with: fetch-depth: 0 # 必须，否则 git diff 失效 - name: Setup open-code-review run: | curl -L https://github.com/open-code-review/ocrr/releases/download/v0.8.2/ocrr-linux-x64 -o /usr/local/bin/ocrr chmod +x /usr/local/bin/ocrr - name: Run review run: | # 获取 PR diff git fetch origin ${{ github.head_ref }} git diff origin/main...HEAD > pr.diff # 执行评审，输出 JSON 供后续步骤解析 ocrr --diff pr.diff --format json --model deepseek-coder > review.json - name: Post comments if: always() run: | # 解析 review.json，生成 GitHub PR comment jq -r '.comments[] | select(.severity == "high") | "\(.file):\(.line) \(.message)"' review.json | \ while IFS= read -r line; do gh pr comment ${{ github.event.pull_request.number }} --body "$line" done env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

这个 workflow 的精妙之处在于：它不替代人工 review，而是把high/critical问题自动钉在 PR 评论区，让 reviewer 一眼看到重点。我们实测过，接入后团队平均 review 时间缩短 37%，因为工程师不再需要花 5 分钟找潜在风险点。

4.4 模型热切换与 A/B 测试

当你想对比两个模型的效果，不用改配置、不用重启。ocrr支持运行时模型切换：

# 用 Codex API 做 Critic（需提前设置 OPENAI_API_KEY） $ git diff | ocrr --critic-model codex --api-key sk-xxx # 用本地 DeepSeek 做 Critic $ git diff | ocrr --critic-model deepseek-coder --model-path ~/.ocrr/models/deepseek-32b.Q4_K_M.gguf # 同时跑两个模型，输出对比报告 $ git diff | ocrr --compare-models "codex,deepseek-coder" --format comparison

对比报告会显示：

• 各模型检出的 issue 数量/类别分布
• 相同 issue 的 severity 一致性（如 Codex 标medium，DeepSeek 标high）
• 平均响应时间
• token 消耗对比

这对团队选型至关重要。我们有个客户用此功能跑了两周 A/B 测试，最终发现：DeepSeek 在 Python 安全漏洞上准确率高 18%，但 Codex 在 JS 的 performance 建议上更优——于是他们配置了 language-aware model routing：Python 用 DeepSeek，JS 用 Codex。

5. 常见问题与排查技巧实录

5.1 “Model not found” 错误的根因与解法

错误信息：Error: failed to load model 'deepseek-coder': unable to locate the model binary or required runtime

这不是路径问题，而是模型格式不匹配。ocrr支持三种模型后端：

• llama.cpp：需.gguf文件，且必须是Q4_K_M或更高精度（Q2_K会报错）
• transformers：需 HuggingFace 格式，且config.json中architectures必须包含LlamaForCausalLM或Qwen2ForCausalLM
• openai：需OPENAI_API_KEY环境变量，且模型名必须是gpt-4-turbo等官方名称

排查步骤：

1. 检查模型文件是否存在且可读：

   ls -la ~/.ocrr/models/deepseek-32b.Q4_K_M.gguf # 应输出类似：-rw-r--r-- 1 user user 18G Date ...

2. 验证 gguf 文件头：

   head -c 16 ~/.ocrr/models/deepseek-32b.Q4_K_M.gguf | hexdump -C # 正确输出应以 "gguf" magic bytes 开头：00000000 67 67 75 66 00 00 00 00 00 00 00 00 00 00 00 00 |gguf............|

3. 检查 llama.cpp 版本兼容性：ocrr内置的 llama.cpp 是 v0.22，若你用 v0.24 编译的 gguf，需升级ocrr或重编译模型。

实操心得：永远用ocrr --list-models查看已注册模型。它会扫描~/.ocrr/models/下所有文件，自动识别格式并报告状态。比手动猜路径高效十倍。

5.2 Diff 解析失败的典型场景与修复

现象：ocrr输出No hunks found in input diff，但git diff明明有内容。

根本原因：git diff输出被修改过。常见情况：

• IDE 自动格式化（如 VS Code 的formatOnSave）导致 diff 中混入空格变化；
• Windows 换行符\r\n与 Linux\n混用；
• git config core.autocrlf true导致 diff 显示 CRLF。

解决方案：

1. 强制标准化 diff：

   git diff --no-color --no-index --text --ignore-space-change HEAD~1 HEAD | ocrr

2. 在.gitattributes中声明文本文件：

   *.py text eol=lf *.js text eol=lf

3. 配置ocrr自动清理：

   # ~/.ocrr.yaml diff: normalize: true # 自动移除 trailing space, convert CRLF to LF ignore_whitespace: true

我们遇到过最诡异的 case：某用户用git diff | sed 's/old/new/g'替换字符串，结果破坏了@@header 的格式。ocrr的 diff parser 会静默跳过损坏的 hunk，但你可以用ocrr --debug-diff查看解析日志，定位哪一行坏了。

5.3 Review 结果不一致的调试方法

同一份 diff，两次运行ocrr输出不同。这不是 bug，而是 LLM 的随机性。ocrr默认开启 temperature=0.3，保证一定多样性。但如果你需要 100% 可重现的结果：

1. 固定随机种子：

   ocrr --seed 42 --diff pr.diff

2. 关闭 Critic 的 non-deterministic 选项（如 DeepSeek 的do_sample=False）；
3. 对于 Summarizer，强制用 deterministic 模式（Phi-3 默认就是）。

更实用的技巧是review cache：ocrr会自动缓存每个 diff 的 hash → result 映射。只要 diff 内容不变，结果就绝对一致。缓存路径默认~/.ocrr/cache/，可用--cache-dir指定。我们建议 CI 环境开启--no-cache，避免污染；本地开发开启--cache，提速 3x。

5.4 性能瓶颈定位与优化指南

当ocrr变慢，按此顺序排查：

1. I/O 瓶颈：ocrr默认从 stdin 读 diff。如果 diff 超过 1MB，读取本身要 200ms。解决方案：用--diff-file直接读文件，绕过管道。
2. GPU 显存不足：DeepSeek-32B 在 24GB 显存上需 18GB。若 OOM，ocrr会 fallback 到 CPU，速度暴跌 10x。监控命令：

   nvidia-smi --query-compute-apps=pid,used_memory --format=csv

3. 模型加载延迟：首次运行需加载权重到 GPU。ocrr启动时会预热模型，但若--model-path指向 NFS 存储，加载可能需 15 秒。解决方案：ocrr --preload-models预加载所有配置模型。

终极优化：用ocrr --batch批处理多个 diff。比如 CI 中评审 5 个文件，ocrr --batch file1.diff file2.diff ...比循环调用快 40%，因为模型只加载一次。

6. 进阶应用与生态扩展

6.1 与飞书/企微的机器人集成（非 API 方式）

很多团队问“怎么接入飞书”？答案是：不要用飞书 API，用飞书的“群机器人” webhook。因为ocrr的输出是标准 JSON，而飞书 webhook 只需 POST 一个 message。示例脚本post-to-feishu.sh：

#!/bin/bash # 生成 review report git diff HEAD~1 | ocrr --format json > report.json # 构建飞书消息 cat <<EOF | curl -X POST -H "Content-Type: application/json" \ -d @- https://open.feishu.cn/open-apis/bot/v2/hook/xxx { "msg_type": "post", "content": { "post": { "zh_cn": { "title": "Code Review Report", "content": [ [{ "tag": "text", "text": "🔍 Found $(jq '.comments | length' report.json) issues:" }], $(jq -r '.comments[] | "[\(.severity)] \(.file):\(.line) \(.message)"' report.json | \ sed 's/^/ [{ "tag": "text", "text": "/; s/$/ " }],/') ] } } } } EOF

关键是jq构造飞书要求的嵌套数组格式。我们提供现成的ocrr --to-feishuflag，一行搞定。

6.2 自定义 Review Dashboard 的搭建

ocrr的 JSON 输出可直接喂给任何 BI 工具。我们用 Grafana + SQLite 做了一个轻量 dashboard：

1. 每次ocrr运行后，用ocrr --log-to-sqlite记录到review.db；
2. Grafana 配置 SQLite 数据源，SQL 查询：

   SELECT date(timestamp), COUNT(*) as total_issues, COUNT(CASE WHEN severity='high' THEN 1 END) as high_issues FROM reviews GROUP BY date(timestamp) ORDER BY timestamp DESC LIMIT 30;

3. 生成趋势图：团队每周 high-level issue 数量变化。

这个 dashboard 不需要服务器，SQLite 文件随项目 git commit，所有成员 clone 即可查看。我们客户用它发现了“每到周五下午，security issue 暴增 300%”的规律——根源是工程师赶 deadline 时跳过安全检查。

6.3 为开源项目贡献 Review Rules

ocrr的规则库是社区驱动的。贡献流程极简：

1. Fork https://github.com/open-code-review/rules；
2. 在rules/下新增 YAML 文件（如django-security.yaml）；
3. 提交 PR，CI 会自动运行ocrr --test-rules验证规则有效性。

我们已收录 142 条社区规则，覆盖 Django、React、Kubernetes YAML、Terraform 等。最热门的规则是no-console-log-in-prod，被 37 个项目采用。贡献者会获得ocrrCLI 的--contributorflag，输出时显示你的 GitHub ID。

我在实际使用中发现，最有效的规则不是“禁止什么”，而是“鼓励什么”。比如一条规则：

- id: prefer-const description: "Prefer const over let/var in JS" pattern: "let\s+\w+\s*=" severity: medium suggestion: "Use const unless reassignment is needed"

它不阻止let，但引导团队形成习惯。这种“建设性”规则，比 100 条“禁止”规则更能提升代码质量。