code-review-graph 深度解析：给 AI 代码审查装上"精准地图"，82 倍 Token 减少背后的工程秘密

前言

2026年7月21日，GitHub Trending 出现了一个现象级的开源项目——code-review-graph。上线当天狂揽 1,641 个 Star，72 小时内突破 23,000 Star，成为当月最受关注的 AI 辅助开发工具之一。

这个工具解决了一个让所有 AI 编程工具用户都头疼的问题：每次代码审查都要重复扫描整个代码库，Token 消耗巨大，响应缓慢，分析还不精准。

code-review-graph 给出的答案是：用 Tree-sitter 把整个代码库解析成结构化知识图谱，存入 SQLite，再通过 MCP 协议暴露给 AI 编程助手，让 AI 只读"该读的代码"。

基准测试结果令人震撼：Token 消耗中位数减少 82 倍，最大减少幅度达到 528 倍。 这不是 PPT 上的理论数字，而是真实项目中的实测数据。

本文将从程序员视角出发，深入拆解 code-review-graph 的三层架构设计、爆炸半径分析原理、MCP 集成细节、增量更新机制，以及如何在大型项目中落地实践。文章包含完整的代码示例、配置指南和生产调优清单。

一、AI 辅助编程的"全量扫描"困境

1.1 从Copilot到Claude Code：Token焦虑从未消失

从 GitHub Copilot 到 Claude Code，从 Cursor 到 Copilot Workspace，AI 编程工具在过去三年里飞速进化。但有一个根本问题始终没有解决：上下文窗口的浪费。

当你打开一个 10 万行代码的 MonoRepo，修改了 3 行代码后让 AI 审查，AI 工具的默认行为是：

1. 读取整个项目目录结构
2. 解析所有文件内容（尤其是最近修改的文件）
3. 尝试理解所有模块之间的依赖关系
4. 最后才给出针对你那 3 行代码的审查意见

第 4 步可能只需要 200 个 Token，但第 1-3 步可能消耗了 200,000 个 Token。 这中间的浪费，就是 code-review-graph 要解决的核心问题。

1.2 三个具体场景，看Token浪费有多严重

场景一：大型前端项目的 PR 审查

一个 React + TypeScript 的中台项目，代码量约 50 万行。你修改了一个 Button 组件的点击样式，让 AI 审查这个 PR。AI 工具的处理流程：

• 读取所有组件文件（约 2000 个 TSX）
• 读取所有样式文件（约 500 个 CSS/SCSS）
• 读取路由配置、状态管理、API 层
• 最终给出的意见是："样式变量命名不够语义化"

Token 消耗：约 8 万 Input Token，其中 95% 与这次修改完全无关。

场景二：微服务架构的 Bug 修复

一个基于 Go 的微服务集群，共 30 个服务，每个服务平均 1 万行代码。你修复了服务 A 中的一个 nil pointer 问题。AI 审查时：

• 读取所有 30 个服务的代码
• 分析服务间调用链路
• 检查依赖的中间件和公共库
• 最后告诉你："这个修复没问题，建议加个日志"

Token 消耗：约 30 万 Input Token，但真正相关的只有服务 A 的 200 行。

场景三：数据库Schema变更的影响评估

一个 PostgreSQL 数据库，有 200 张表。你修改了一张订单表的字段类型。AI 审查这个 Schema 变更：

• 读取所有 DDL 文件
• 分析所有 JOIN 语句
• 检查 ORM 模型和 DAO 层
• 评估 BI 报表依赖

Token 消耗：约 15 万，但真正需要评估的只有 5 张直接相关的表。

1.3 现有解决方案的局限性

针对这个问题，社区已经提出过几种解决思路：

基于文件通配符的上下文注入：在 .claude.md 或 CLAUDE.md 中手动列出"需要关注哪些文件"。缺点是维护成本高，容易遗漏，容易过时。

语义搜索增强：用 Embedding 模型对代码做向量化，审查时检索相关片段。缺点是 Embedding 质量参差不齐，召回率和精确率难以同时保证，且部署成本高。

基于规则的依赖分析：用 dep 或类似工具分析 import 关系。缺点是只能处理语言内置的 import/export，无法理解业务层面的调用语义。

code-review-graph 的创新之处在于：用编译器级别的 AST 解析（Tree-sitter）生成精确的代码知识图谱，然后用图查询代替模糊搜索，让 AI 拿到的是结构化的、可信赖的依赖关系，而不是靠概率匹配的文本片段。

二、code-review-graph 是什么

2.1 核心定义

code-review-graph 是一个本地优先的代码知识图谱构建工具，专为 AI 辅助代码审查场景优化。它的核心能力：

• 用 Tree-sitter 将代码库解析为 AST（抽象语法树）
• 从 AST 中提取节点（函数、类、变量、导入）和边（调用、继承、测试覆盖）
• 将图谱存入本地 SQLite 数据库（零依赖，纯 Python）
• 通过 MCP（Model Context Protocol） 协议暴露给 AI 编程助手
• AI 审查时，根据图谱计算变更的"爆炸半径"，只返回真正相关的文件

2.2 关键数据

2.3 架构总览

┌─────────────────────────────────────────────────────────┐
│                    AI 编程助手                           │
│            (Claude Code / Cursor / Codex)               │
└──────────────────────┬──────────────────────────────────┘
                       │ MCP 协议调用
                       ▼
┌──────────────────────────────────────────────────────────┐
│               MCP Server (code-review-graph)             │
│  ┌─────────────────────────────────────────────────────┐│
│  │            图查询引擎 (Graph Query Engine)           ││
│  │         SQLite → 图遍历 → 影响文件列表               ││
│  └─────────────────────────────────────────────────────┘│
└──────────────────────┬──────────────────────────────────┘
                       │ SQLite 图数据库查询
                       ▼
┌──────────────────────────────────────────────────────────┐
│              SQLite 知识图谱数据库                        │
│   节点表: functions, classes, imports, variables          │
│   边表: calls, inherits, tests, exports                   │
└──────────────────────┬──────────────────────────────────┘
                       │ AST 增量解析
                       ▼
┌──────────────────────────────────────────────────────────┐
│              Tree-sitter 解析引擎                          │
│     Python/JS/Go/Rust/Java/C++/TypeScript/...           │
└──────────────────────┬──────────────────────────────────┘
                       │ 代码文件
                       ▼
                    代码库（Codebase）

三、三层架构深度解析

3.1 第一层：Tree-sitter AST 解析

3.1.1 为什么选 Tree-sitter

Tree-sitter 是 GitHub 开发的一个增量式语法解析器生成器。它的核心优势：

1. 语言无关：可以为任何编程语言生成解析器，当前支持 40+ 种语言
2. 增量解析：只重新解析变更的文件，而不是整个代码库
3. 确定性输出：同样的代码每次解析结果完全一致
4. 语义友好：直接生成 AST，节点类型与语言语法对应（function_declaration, class_def, import_statement 等）

相比之下，传统的正则表达式分析无法理解语法结构，AST 分析比正则精确 100 倍。

3.1.2 节点提取：从 AST 到图节点

code-review-graph 对每种支持的语言定义了节点提取规则。以 Python 为例：

# 从 Python AST 中提取的关键节点类型
NODE_TYPES = {
    "function_definition": FunctionNode,     # 函数定义
    "class_definition": ClassNode,           # 类定义
    "async_function_definition": FunctionNode, # 异步函数
    "import_statement": ImportNode,          # import 语句
    "import_from_statement": ImportNode,     # from ... import
    "variable_declaration": VariableNode,   # 变量声明
    "decorator": DecoratorNode,             # 装饰器
    "type_alias": TypeAliasNode,             # 类型别名 (Python 3.10+)
}

# 边的类型
EDGE_TYPES = {
    "calls": CallEdge,           # 函数调用
    "imports": ImportEdge,       # 导入关系
    "inherits": InheritEdge,     # 类继承
    "decorates": DecorateEdge,   # 装饰器应用
    "raises": RaiseEdge,         # 异常抛出
    "references": RefEdge,       # 变量引用
}

3.1.3 实际解析示例

给一段简单的 Python 代码：

# auth.py
from datetime import datetime
import jwt

class AuthService:
    def __init__(self, secret: str):
        self.secret = secret
    
    def create_token(self, user_id: str) -> str:
        payload = {"user_id": user_id, "exp": datetime.now()}
        return jwt.encode(payload, self.secret, algorithm="HS256")
    
    def verify_token(self, token: str) -> dict:
        return jwt.decode(token, self.secret, algorithms=["HS256"])

Tree-sitter 解析后生成的图节点和边：

节点:
  - AuthService (class_definition, auth.py:4)
  - __init__ (function_definition, auth.py:5)
  - create_token (function_definition, auth.py:8)
  - verify_token (function_definition, auth.py:12)
  - secret (variable, auth.py:5)

边:
  - create_token --calls--> jwt.encode
  - verify_token --calls--> jwt.decode
  - AuthService --contains--> create_token
  - AuthService --contains--> verify_token
  - __init__ --imports--> jwt

3.1.4 跨文件依赖追踪

Tree-sitter 本身是单文件解析器，code-review-graph 通过汇总分析所有文件的 import 语句来构建跨文件依赖图：

# config.py
from .auth import AuthService
from .database import Database

# db.py
from .models import User
import sqlalchemy

# 最终生成的跨文件依赖图（简化版）
DependencyGraph:
  auth.py:AuthService
    └── imported_by: [config.py]
    └── calls: [jwt.encode, jwt.decode]
  
  db.py:Database
    └── imported_by: [config.py, api.py]
    └── uses: [sqlalchemy]
  
  models.py:User
    └── imported_by: [db.py, api.py]

3.2 第二层：SQLite 图数据库

3.2.1 为什么用 SQLite

这是一个有意为之的选择，而不是用 Neo4j 或其他图数据库：

code-review-graph 的核心洞察是：它不需要复杂的图算法（PageRank、社区发现等），只需要高效的邻接查询（"查找所有调用这个函数的文件"）。 SQLite 的 B-Tree 索引在这种情况下性能足够好，而且完全零运维。

3.2.2 数据库 Schema 设计

-- 节点表：存储所有代码实体
CREATE TABLE nodes (
    id INTEGER PRIMARY KEY,
    file_path TEXT NOT NULL,
    node_type TEXT NOT NULL,       -- function, class, import, variable
    symbol_name TEXT NOT NULL,     -- 函数名、类名等
    start_line INTEGER NOT NULL,
    end_line INTEGER NOT NULL,
    language TEXT NOT NULL,
    fqn TEXT NOT NULL,              -- Fully Qualified Name，如 auth.py:AuthService.create_token
    content_hash TEXT NOT NULL,     -- 用于增量更新检测
    metadata JSON,                  -- 额外元数据（参数列表、返回值类型等）
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 索引
CREATE INDEX idx_nodes_fqn ON nodes(fqn);
CREATE INDEX idx_nodes_file ON nodes(file_path);
CREATE INDEX idx_nodes_type ON nodes(node_type);

-- 边表：存储节点之间的关系
CREATE TABLE edges (
    id INTEGER PRIMARY KEY,
    source_id INTEGER NOT NULL,
    target_id INTEGER NOT NULL,     -- 可为空（如外部库调用）
    edge_type TEXT NOT NULL,        -- calls, imports, inherits, tests, etc.
    source_file TEXT NOT NULL,
    target_file TEXT NOT NULL,
    confidence REAL DEFAULT 1.0,    -- 置信度，有些关系是启发式推断的
    FOREIGN KEY (source_id) REFERENCES nodes(id),
    FOREIGN KEY (target_id) REFERENCES nodes(id)
);

CREATE INDEX idx_edges_source ON edges(source_id);
CREATE INDEX idx_edges_target ON edges(target_id);
CREATE INDEX idx_edges_type ON edges(edge_type);

-- 文件表：存储文件元数据，用于增量更新
CREATE TABLE files (
    file_path TEXT PRIMARY KEY,
    last_modified TIMESTAMP,
    content_hash TEXT NOT NULL,
    language TEXT,
    node_count INTEGER DEFAULT 0,
    edge_count INTEGER DEFAULT 0
);

3.2.3 图查询：爆炸半径分析的核心

爆炸半径分析本质上是一系列图遍历查询。当一个文件发生变更时，查询流程：

def blast_radius_analysis(file_path: str) -> dict:
    """计算变更文件的影响范围"""
    
    # 第一层：谁调用了这个文件中的函数？
    callers = db.execute("""
        SELECT DISTINCT n.file_path, n.symbol_name, n.start_line
        FROM edges e
        JOIN nodes n ON e.source_id = n.id
        WHERE e.target_file = ?
          AND e.edge_type = 'calls'
    """, (file_path,)).fetchall()
    
    # 第二层：这些调用者的调用者（追溯上游依赖）
    downstream = set(f.file_path for f in callers)
    
    for caller_file in downstream:
        upstream = db.execute("""
            SELECT DISTINCT target_file
            FROM edges
            WHERE source_file = ?
              AND edge_type IN ('calls', 'imports')
        """, (caller_file,)).fetchall()
        downstream.update(f.target_file for f in upstream)
    
    # 第三层：哪些测试覆盖了这个文件？
    test_files = db.execute("""
        SELECT DISTINCT source_file
        FROM edges
        WHERE target_file = ?
          AND edge_type = 'tests'
    """, (file_path,)).fetchall()
    
    # 第四层：哪些文件继承/实现了这个类？
    implementing_files = db.execute("""
        SELECT DISTINCT source_file
        FROM edges
        WHERE target_file = ?
          AND edge_type IN ('inherits', 'implements')
    """, (file_path,)).fetchall()
    
    return {
        "direct_callers": callers,
        "downstream_impact": list(downstream),
        "affected_tests": test_files,
        "implementations": implementing_files,
        "risk_score": calculate_risk_score(callers, downstream, test_files)
    }

3.2.4 性能数据

在 Linux 内核（2000 万行代码）上的测试数据：

3.3 第三层：MCP 协议集成

3.3.1 什么是 MCP

MCP（Model Context Protocol）是 Anthropic 在 2025 年底推出的标准化协议，旨在为 AI 模型提供统一的工具调用接口。类似于 LSP（Language Server Protocol）为编程语言工具提供的标准化，MCP 为 AI 编程助手提供工具调用标准化。

MCP 的核心优势：

• 工具发现的标准化：AI 助手可以自动发现可用的工具
• 输入输出的标准化：JSON Schema 格式的工具描述
• 状态管理的标准化：工具可以维护会话状态

3.3.2 code-review-graph 的 MCP 工具集

code-review-graph 暴露了 30+ 个 MCP 工具，按功能分为五类：

第一类：图构建工具

{
  "name": "crg_build",
  "description": "从当前代码库构建或更新知识图谱",
  "inputSchema": {
    "type": "object",
    "properties": {
      "incremental": {
        "type": "boolean",
        "description": "是否为增量构建，默认 true",
        "default": true
      },
      "files": {
        "type": "array",
        "items": {"type": "string"},
        "description": "指定要解析的文件路径，为空则全量"
      },
      "force": {
        "type": "boolean",
        "description": "强制重新解析，不使用缓存"
      }
    }
  }
}

第二类：影响分析工具

{
  "name": "crg_blast_radius",
  "description": "分析文件变更的爆炸半径",
  "inputSchema": {
    "type": "object",
    "properties": {
      "file": {
        "type": "string",
        "description": "变更的文件路径"
      },
      "depth": {
        "type": "integer",
        "description": "追溯深度，默认为 2",
        "default": 2
      },
      "include_tests": {
        "type": "boolean",
        "description": "是否包含测试文件",
        "default": true
      }
    }
  }
}

第三类：依赖查询工具

{
  "name": "crg_who_calls",
  "description": "查找所有调用指定函数的文件和位置",
  "inputSchema": {
    "type": "object",
    "properties": {
      "symbol": {
        "type": "string",
        "description": "函数或方法名（支持 FQN）"
      },
      "file_scope": {
        "type": "string",
        "description": "限定在特定文件/目录下搜索"
      }
    }
  }
}

第四类：结构理解工具

{
  "name": "crg_file_structure",
  "description": "获取文件的代码结构概览（函数、类、导入列表）",
  "inputSchema": {
    "type": "object",
    "properties": {
      "file": {
        "type": "string",
        "description": "文件路径"
      },
      "depth": {
        "type": "integer",
        "description": "嵌套展示深度"
      }
    }
  }
}

第五类：变更感知工具

{
  "name": "crg_changed_functions",
  "description": "根据 Git diff 识别变更涉及的函数列表",
  "inputSchema": {
    "type": "object",
    "properties": {
      "diff": {
        "type": "string",
        "description": "Git diff 内容"
      }
    }
  }
}

3.3.3 AI 助手的工作流改造

没有 code-review-graph 时，Claude Code 处理代码审查的流程：

用户: 帮我审查这个 PR
↓
Claude: 读取所有文件...
       (消耗 200,000 Token)
↓
Claude: 基于全量上下文给出审查意见
       (可能遗漏关键依赖，或给出泛泛的建议)

有了 code-review-graph 后，Claude Code 的流程变为：

用户: 帮我审查这个 PR
↓
Claude: 调用 crg_changed_functions(diff) 获取变更函数列表
       (消耗 200 Token)
↓
Claude: 对每个变更函数调用 crg_blast_radius(file) 
       获取影响范围
       (消耗 500 Token × N 个函数)
↓
Claude: 只读取爆炸半径内的相关文件
       (消耗 5,000 Token，只读真正需要的)
↓
Claude: 基于精准上下文给出深度审查意见
       (识别出了被遗漏的测试用例，建议了相关模块的回归测试)

3.4 增量更新机制

3.4.1 内容哈希检测

code-review-graph 通过内容哈希来检测哪些文件发生了变化：

import hashlib
import os
from pathlib import Path

def compute_file_hash(file_path: str) -> str:
    """计算文件的 SHA-256 哈希"""
    hasher = hashlib.sha256()
    with open(file_path, 'rb') as f:
        # 大文件分块读取
        for chunk in iter(lambda: f.read(8192), b''):
            hasher.update(chunk)
    return hasher.hexdigest()

def detect_changes(repo_path: str) -> dict:
    """检测自上次构建以来发生变化的文件"""
    changes = {"modified": [], "added": [], "deleted": []}
    db = sqlite3.connect("code_graph.db")
    
    # 检查修改和新增
    for root, _, files in os.walk(repo_path):
        for file in files:
            if not is_code_file(file):
                continue
            
            abs_path = os.path.join(root, file)
            rel_path = os.path.relpath(abs_path, repo_path)
            current_hash = compute_file_hash(abs_path)
            
            row = db.execute(
                "SELECT content_hash FROM files WHERE file_path = ?",
                (rel_path,)
            ).fetchone()
            
            if row is None:
                changes["added"].append(rel_path)
            elif row[0] != current_hash:
                changes["modified"].append(rel_path)
    
    # 检查删除
    for row in db.execute("SELECT file_path FROM files"):
        if not os.path.exists(os.path.join(repo_path, row[0])):
            changes["deleted"].append(row[0])
    
    return changes

3.4.2 增量构建策略

def incremental_build(changes: dict):
    """仅重新解析变化的文件"""
    for file_path in changes["added"] + changes["modified"]:
        # 删除旧节点和边
        db.execute("DELETE FROM edges WHERE source_file = ? OR target_file = ?", 
                   (file_path, file_path))
        db.execute("DELETE FROM nodes WHERE file_path = ?", (file_path,))
        
        # 解析新内容
        nodes, edges = parse_file(file_path)
        
        # 插入新节点和边
        insert_nodes(nodes)
        insert_edges(edges)
        
        # 更新文件表
        db.execute("""
            INSERT OR REPLACE INTO files 
            (file_path, content_hash, node_count, edge_count)
            VALUES (?, ?, ?, ?)
        """, (file_path, compute_file_hash(file_path), 
               len(nodes), len(edges)))
    
    for file_path in changes["deleted"]:
        db.execute("DELETE FROM edges WHERE source_file = ? OR target_file = ?", 
                   (file_path, file_path))
        db.execute("DELETE FROM nodes WHERE file_path = ?", (file_path,))
        db.execute("DELETE FROM files WHERE file_path = ?", (file_path,))
    
    db.commit()

关键优化：即使只修改了一行代码，导入关系可能会导致其他文件的边发生变化。例如，在 auth.py 中添加了一个新函数 generate_refresh_token，这个函数被 api.py 调用，那么虽然 api.py 的代码没变，但 api.py 对 auth.py 的边会增加。code-review-graph 通过传播分析来处理这种情况：

def propagate_changes(file_path: str):
    """传播变更影响，更新相关文件的边"""
    # 找出所有导入这个文件的模块
    importers = db.execute("""
        SELECT DISTINCT source_file
        FROM edges
        WHERE target_file = ? AND edge_type = 'imports'
    """, (file_path,)).fetchall()
    
    for importer in importers:
        # 重新分析导入这个文件后是否引入了新的函数调用
        reanalyze_import_relationships(importer)

四、快速开始：从安装到配置

4.1 安装

# 方法一：pip 直接安装
pip install code-review-graph

# 方法二：使用 uv（推荐，性能更好）
uv tool install code-review-graph

# 方法三：从源码安装
git clone https://github.com/xxx/code-review-graph.git
cd code-review-graph
pip install -e .

要求：Python 3.10+，建议安装 uv 以获得更快的依赖解析。

4.2 自动配置（支持所有主流 AI 编程工具）

# 自动检测并配置所有支持的平台
code-review-graph install

install 命令会执行三件事：

1. 检测已安装的 AI 编码工具（Claude Code、Cursor、Coze Codex、Gemini CLI 等）
2. 为每个工具写入正确的 MCP 配置（写入 .mcp.json 或对应的配置文件）
3. 注入图感知指令到平台规则（让 AI 优先使用图查询工具）

输出示例：

✓ Detected platforms:
  - Claude Code (~/projects/myapp)
  - Cursor (cursor_settings.json)
  - Gemini CLI

✓ Writing MCP configuration...
  - Claude Code: ~/.claude/code-review-graph.json
  - Cursor: ~/Library/Application Support/Cursor/User/globalSettings/cursor_mcp.json
  - Gemini CLI: ~/.gemini/mcp_config.json

✓ Injecting graph-aware instructions into platform rules...

Installation complete! Run 'code-review-graph build' to build your graph.

4.3 为特定平台单独配置

# 仅配置 Claude Code
code-review-graph install --platform claude-code

# 仅配置 Cursor
code-review-graph install --platform cursor

# 仅配置 Gemini CLI
code-review-graph install --platform gemini-cli

4.4 构建知识图谱

# 在项目根目录执行全量构建
code-review-graph build

# 仅构建特定目录
code-review-graph build --path ./src/api

# 强制重新构建（不使用缓存）
code-review-graph build --force

构建过程会显示进度：

Building code graph for: /Users/john/project
Language: Python | Files: 234 | Progress: [████████████] 100%

Parsed: 234 files
Extracted: 1,847 nodes, 4,293 edges
Database: code_graph.db (3.2 MB)

Build complete in 12.3s

4.5 增量更新

code-review-graph 支持与 Git 钩子集成，实现自动化增量更新：

# 生成 Git post-commit 钩子
code-review-graph install --git-hook

这会在 .git/hooks/post-commit 中添加：

#!/bin/bash
# Auto-update code graph after each commit
code-review-graph build --incremental 2>/dev/null

每次 git commit 后，图谱会自动增量更新，耗时 < 2 秒。

五、生产实战：在大型 MonoRepo 中的落地配置

5.1 大型前端项目配置

假设有一个 Next.js + TypeScript 项目，目录结构：

frontend/
├── apps/
│   ├── web/          # 主站 (5万行)
│   ├── admin/        # 管理后台 (2万行)
│   └── mobile/       # 移动端 H5 (1万行)
├── packages/
│   ├── ui/           # 组件库
│   ├── hooks/        # 公共 hooks
│   ├── utils/        # 工具函数
│   └── api-client/   # API 客户端
└── turbo.json

配置 .code-review-graph.json：

{
  "version": "1.0",
  "root": ".",
  "languages": ["typescript", "javascript"],
  "exclude": [
    "**/node_modules/**",
    "**/.next/**",
    "**/dist/**",
    "**/build/**",
    "**/*.test.ts",
    "**/*.spec.ts",
    "**/__tests__/**",
    "**/coverage/**"
  ],
  "include_only": [
    "apps/**/src/**",
    "packages/**/src/**"
  ],
  "incremental_update": true,
  "git_hook": true,
  "mcp": {
    "max_depth": 3,
    "include_tests": true,
    "risk_threshold": 0.7
  }
}

增量更新场景：修改 packages/ui/src/Button.tsx：

$ code-review-graph blast-radius packages/ui/src/Button.tsx

📊 Blast Radius Analysis: packages/ui/src/Button.tsx

🔴 High Impact (direct usage):
  - apps/web/src/components/Header.tsx: Line 23
  - apps/web/src/components/Footer.tsx: Line 45
  - apps/admin/src/pages/Dashboard.tsx: Line 12

🟡 Medium Impact (indirect usage):
  - packages/forms/src/FormField.tsx (uses Button)
  - apps/mobile/src/screens/Home.tsx (uses FormField → Button)

🟢 Low Impact (tests only):
  - packages/ui/__tests__/Button.test.tsx
  - apps/web/__tests__/Header.test.tsx

📋 Risk Score: 0.72 (HIGH)
   This component has 6+ usage locations across 3 apps.
   Recommended: Run full regression tests before merge.

🔗 Recommended files for AI review:
  - packages/ui/src/Button.tsx (modified)
  - apps/web/src/components/Header.tsx
  - apps/web/src/components/Footer.tsx
  - packages/forms/src/FormField.tsx

5.2 Go 微服务架构配置

假设有一个基于 Go 的微服务集群：

services/
├── user-service/      # 用户服务 (Go)
├── order-service/     # 订单服务 (Go)
├── payment-service/   # 支付服务 (Go)
├── notification-svc/  # 通知服务 (Go)
└── gateway/           # API 网关 (Go)

配置 .code-review-graph.json：

{
  "version": "1.0",
  "root": "services",
  "languages": ["go"],
  "exclude": [
    "**/vendor/**",
    "**/*_test.go",
    "**/mocks/**",
    "**/proto/*.pb.go"
  ],
  "analysis": {
    "intra_pkg_calls": true,
    "interface_implementations": true,
    "goroutine_spawns": true,
    "channel_uses": true
  },
  "go_specific": {
    "track_context_values": true,
    "track_errors": true,
    "track_logging": true
  }
}

当修改 payment-service/internal/domain/order.go 中的 ProcessPayment 函数时：

$ code-review-graph blast-radius services/payment-service/internal/domain/order.go

📊 Blast Radius Analysis: services/payment-service/internal/domain/order.go

🔴 Critical Path (direct callers):
  - order-service/internal/handler/payment_callback.go: Line 34
  - gateway/internal/middleware/payment_auth.go: Line 89

🟡 Downstream Services (gRPC/HTTP calls):
  - notification-svc/internal/service/notify.go (sends payment success SMS)
  - user-service/internal/service/balance.go (updates user balance)

🟢 Tests:
  - services/payment-service/internal/domain/order_test.go
  - services/payment-service/internal/integration/payment_flow_test.go

⚠️ Breaking Change Check:
  - Public interface: ProcessPayment(paymentID, amount, method) → NO CHANGE
  - Return type: (*PaymentResult, error) → NO CHANGE
  - If only internal logic changed: SAFE for consumers

📋 Risk Score: 0.85 (CRITICAL)
   Changes to this domain logic affect order service and gateway.
   Recommended:
   1. Update unit tests for ProcessPayment
   2. Run payment-service integration tests
   3. Notify order-service team for regression
   4. Update API docs if behavior changed

5.3 CI/CD 集成

5.3.1 GitHub Actions 集成

# .github/workflows/code-review.yml
name: AI Code Review

on:
  pull_request:
    paths-ignore:
      - '**.md'
      - '**.txt'
      - 'docs/**'

jobs:
  build-graph:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Setup Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      
      - name: Install code-review-graph
        run: pip install code-review-graph
      
      - name: Build code graph
        run: |
          code-review-graph build --incremental
      
      - name: Upload graph artifact
        uses: actions/upload-artifact@v4
        with:
          name: code-graph
          path: code_graph.db

  ai-review:
    needs: build-graph
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      
      - name: Download graph artifact
        uses: actions/download-artifact@v4
        with:
          name: code-graph
      
      - name: Install code-review-graph
        run: pip install code-review-graph
      
      - name: Run AI Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          # Claude Code will automatically use the MCP tools
          claude --print --dangerously-skip-permissions \
            "Review this PR. Focus on files with high blast radius."

      - name: Post review comment
        uses: actions/github-script@v7
        with:
          script: |
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: 'AI Code Review completed. Check the workflow logs for details.'
            })

5.3.2 与 GitLab CI 集成

# .gitlab-ci.yml
stages:
  - build
  - review

code-graph:
  stage: build
  image: python:3.11-slim
  before_script:
    - pip install code-review-graph
  script:
    - code-review-graph build --incremental
  artifacts:
    paths:
      - code_graph.db
    expire_in: 1 day

ai-review:
  stage: review
  image: python:3.11-slim
  needs:
    - job: code-graph
      artifacts: true
  before_script:
    - pip install code-review-graph anthropic
  script:
    - |
      # Get diff from merge request
      DIFF=$(git diff --no-color $CI_MERGE_REQUEST_TARGET_BRANCH_SHA...$CI_COMMIT_SHA)
      # Run AI review with blast radius context
      claude --print --dangerously-skip-permissions \
        "Review this MR. First use crg_blast_radius to identify affected files."
  only:
    - merge_requests

六、性能优化与生产调优

6.1 大型代码库的图谱构建优化

6.1.1 并行解析

code-review-graph 默认使用单线程解析。对于大型代码库，可以启用并行解析：

# 使用 8 个 worker 并行解析
code-review-graph build --workers 8

# 或在配置文件中指定
{
  "parallel": {
    "enabled": true,
    "workers": 8
  }
}

性能对比（Linux 内核，2000 万行代码）：

6.1.2 增量构建优化

# 仅解析自上次构建以来变更的文件
code-review-graph build --incremental

# 配合 Git 使用，只解析 HEAD 差异中的文件
code-review-graph build --git-diff HEAD~1

# 设置增量阈值，大于该值的文件跳过重新解析
code-review-graph build --incremental --unchanged-threshold 10

6.2 SQLite 查询优化

对于超大型代码库（100 万行+），可以启用以下优化：

{
  "sqlite": {
    "cache_size": -64000,     // 64MB 页缓存
    "temp_store": "memory",   // 临时表放内存
    "journal_mode": "WAL",    // Write-Ahead Logging，并发读写
    "synchronous": "NORMAL"   // 比 FULL 更快，仅保证断电安全
  }
}

# 应用优化
code-review-graph db tune --cache-size 64 --journal-mode WAL

6.3 图查询加速

对于需要频繁查询的场景，可以预计算常用查询结果：

# 预计算所有函数的调用图
code-review-graph precompute --type call-graph

# 预计算所有类的继承树
code-review-graph precompute --type inheritance-tree

# 预计算所有测试的覆盖关系
code-review-graph precompute --type test-coverage

# 预计算所有包的依赖图
code-review-graph precompute --type dependency-graph

6.4 内存优化

# 设置最大内存使用（GB）
code-review-graph build --max-memory 4

# 流式处理大文件（避免一次性加载到内存）
code-review-graph build --stream-large-files

# 压缩数据库
code-review-graph db vacuum

七、与其他工具的对比

7.1 vs 传统静态分析工具

7.2 vs 商业 AI 代码审查工具

7.3 实际场景对比测试

以一个 50 万行代码的 React TypeScript 项目为例，对比 AI 代码审查的 Token 消耗和响应质量：

场景：修改 Button 组件的点击处理逻辑

八、局限性与未来展望

8.1 当前局限性

1. MCP 工具需要 AI 主动调用：如果 AI 助手不主动使用 MCP 工具，图谱的优势无法发挥。需要配合 CLAUDE.md 或平台规则注入来引导 AI 行为。

2. 跨语言依赖分析较弱：当一个 Go 服务调用 Python 微服务时，code-review-graph 无法自动追踪（需要 gRPC/proto 定义）。

3. 动态特性处理不完善：反射、反射、eval、动态 import 等在运行时才能确定的关系，静态分析无法覆盖。

4. 超大型 MonoRepo 挑战：超过 1000 万行代码时，SQLite 的单线程写入可能成为瓶颈。

5. 需要维护更新：代码库结构变化后需要手动触发增量构建（虽然 Git 钩子可以缓解）。

8.2 Roadmap 与未来方向

根据 GitHub Issues 和社区讨论，未来版本计划：

• 支持更多 AI 平台：JetBrains 插件、VS Code 原生集成
• 分布式图存储：支持 PostgreSQL + Apache AGE 扩展，适合超大型代码库
• 实时协作：多人同时审查时共享图谱视图
• 自定义规则引擎：允许用户定义自己的图查询规则和影响评估策略
• AI 生成测试：基于爆炸半径自动生成回归测试用例
• 安全漏洞传播分析：追踪漏洞代码的调用链路，识别所有受影响的服务

九、总结

code-review-graph 解决的不是"如何让 AI 更好地理解代码"这个老问题，而是"如何让 AI 只读它真正需要读的那部分代码"这个新问题。

通过 Tree-sitter + SQLite 图谱 + MCP 协议的组合，它实现了：

• Token 消耗降低 82 倍（中位数），最高 528 倍
• 上下文精准度大幅提升：AI 不再被无关代码误导
• 审查质量提升：能识别遗漏的测试、遗漏的依赖、遗漏的回归范围
• 零运维：SQLite 无需独立服务，本地部署完全私有

对于任何一个规模超过 10 万行代码的团队，code-review-graph 都是值得一试的工具。它的安装配置不超过 10 分钟，但带来的 Token 节省和审查质量提升是实实在在的。

关键收获：

1. AI 辅助编程的瓶颈不是模型能力，而是上下文管理能力
2. 知识图谱 + 图查询是结构化理解代码的最佳方式
3. 本地优先的设计哲学在数据隐私敏感的今天越来越重要
4. MCP 协议正在成为 AI 编程工具的事实标准

相关资源：

• GitHub：github.com/sukk/awesomer-claude（Awesome Claude Skills 资源列表中也收录了相关 MCP 工具）
• 官方文档：Tree-sitter 增量解析指南
• MCP 协议规范：Model Context Protocol 官方文档