用 RAG 和 GitLab Webhook 构建业务级 AI Code Review 系统

type ChangeStatus = "added" | "modified" | "deleted" | "renamed";

interface Change {
  filePath: string;
  status: ChangeStatus;
  additions: number;
  deletions: number;
  diff: string;
}

interface Chunk {
  id: string;
  files: Change[];
  estimatedTokens: number;
  averageWeight: number;
}

class DiffProcessor {
  private readonly ignoredExts = new Set([
    ".lock",
    ".png",
    ".jpg",
    ".jpeg",
    ".gif",
    ".css",
    ".scss",
    ".less",
  ]);

  private readonly coreDirs = [
    "src/core",
    "src/services",
    "src/domain",
    "packages/business",
  ];

  private readonly maxTokensPerChunk = 30_000;

  processChanges(changes: Change[]): Chunk[] {
    const filtered = changes
      .filter((change) => !this.shouldIgnore(change))
      .sort((a, b) => this.calculateWeight(b) - this.calculateWeight(a));

    return this.groupIntoChunks(filtered);
  }

  private shouldIgnore(change: Change): boolean {
    if (change.status === "deleted") return true;

    const ext = this.getExt(change.filePath);
    if (this.ignoredExts.has(ext)) return true;

    return false;
  }

  private calculateWeight(change: Change): number {
    let weight = 1;

    if (this.coreDirs.some((dir) => change.filePath.startsWith(dir))) {
      weight += 5;
    }

    if (change.filePath.includes("permission")) {
      weight += 3;
    }

    if (change.filePath.includes("payment") || change.filePath.includes("order")) {
      weight += 3;
    }

    return weight;
  }

  private groupIntoChunks(changes: Change[]): Chunk[] {
    const chunks: Chunk[] = [];
    let current: Change[] = [];
    let currentTokens = 0;

    for (const change of changes) {
      const tokens = this.estimateTokens(change.diff);

      if (current.length > 0 && currentTokens + tokens > this.maxTokensPerChunk) {
        chunks.push(this.createChunk(current));
        current = [];
        currentTokens = 0;
      }

      current.push(change);
      currentTokens += tokens;
    }

    if (current.length > 0) {
      chunks.push(this.createChunk(current));
    }

    return chunks;
  }

  private createChunk(files: Change[]): Chunk {
    const totalTokens = files.reduce(
      (sum, file) => sum + this.estimateTokens(file.diff),
      0,
    );

    const totalWeight = files.reduce(
      (sum, file) => sum + this.calculateWeight(file),
      0,
    );

    return {
      id: crypto.randomUUID(),
      files,
      estimatedTokens: totalTokens,
      averageWeight: totalWeight / files.length,
    };
  }

  private estimateTokens(text: string): number {
    return Math.ceil(text.length / 3);
  }

  private getExt(filePath: string): string {
    const index = filePath.lastIndexOf(".");
    return index >= 0 ? filePath.slice(index) : "";
  }
}

{
  "summary": "订单取消逻辑新增了超时判断，超过配置时间后不允许用户主动取消订单。",
  "changedModules": ["order-cancel", "order-status"],
  "businessActions": ["取消订单", "状态流转", "超时校验"],
  "riskKeywords": ["边界时间", "状态一致性", "并发取消"],
  "files": [
    "src/services/order/cancel.ts",
    "src/domain/order/status.ts"
  ]
}

{
  "id": "incident-2025-order-cancel-001",
  "title": "订单取消状态并发更新导致状态回滚",
  "content": "事故原因、触发条件、修复方式、预防规则...",
  "module": "order",
  "tags": ["订单取消", "状态机", "并发"],
  "severity": "high",
  "sourceType": "incident-review"
}

cosine_similarity(A, B) = (A · B) / (||A|| * ||B||)

你是一个负责核心业务系统 Code Review 的工程助手。

审查目标：
- 找出可能导致线上故障、数据错误、权限问题、并发问题、兼容性问题的代码变更。
- 结合历史事故和业务规则判断风险。
- 不要对无关代码风格提出建议。
- 如果没有明确风险，返回“未发现高风险问题”。

代码改动摘要：
{{change_summary}}

相关历史经验：
{{retrieved_knowledge}}

代码 Diff 和上下文：
{{diff_context}}

输出要求：
- 按文件和行号指出风险点。
- 说明风险触发条件。
- 说明为什么与历史经验相关。
- 给出可执行的修复建议。
- 标注风险级别：high / medium / low。

{
  "issues": [
    {
      "riskLevel": "high",
      "file": "src/services/order/cancel.ts",
      "line": 128,
      "title": "取消订单缺少状态幂等校验",
      "reason": "当前逻辑在并发请求下可能重复执行取消流程，和历史事故“订单状态并发更新导致状态回滚”的风险模式相似。",
      "suggestion": "在更新状态时增加当前状态条件，并对重复取消请求返回幂等结果。",
      "relatedKnowledgeIds": ["incident-2025-order-cancel-001"]
    }
  ]
}

class ReviewService {
  async processMergeRequest(params: {
    projectId: number;
    mergeRequestId: number;
    changes: Change[];
  }) {
    const processor = new DiffProcessor();
    const chunks = processor.processChanges(params.changes);

    const reportId = this.createReportId(params.projectId, params.mergeRequestId);

    await Promise.all(
      chunks.map((chunk, index) =>
        this.reviewChunk({
          reportId,
          chunkIndex: index,
          chunksLen: chunks.length,
          chunk,
        }),
      ),
    );

    return this.tryAggregateReport(reportId, chunks.length);
  }

  private async reviewChunk(params: {
    reportId: string;
    chunkIndex: number;
    chunksLen: number;
    chunk: Chunk;
  }) {
    const result = await this.callReviewModel(params.chunk);
    await reportStore.saveChunkResult(params.reportId, params.chunkIndex, result);
  }

  private createReportId(projectId: number, mergeRequestId: number): string {
    return `${projectId}:${mergeRequestId}:${Date.now()}`;
  }

  private async callReviewModel(chunk: Chunk) {
    // 调用 LLM、RAG 检索和最终 Review
  }

  private async tryAggregateReport(reportId: string, chunksLen: number) {
    const report = await reportStore.get(reportId);

    if (!report || report.chunks.length !== chunksLen) {
      return null;
    }

    return aggregateReviewReport(report.chunks);
  }
}

interface StorageReport {
  [reportId: string]: {
    chunks: Array<{
      chunkIndex: number;
      issues: unknown[];
    }>;
  };
}

function isAllChunksDone(
  reportStore: StorageReport,
  reportId: string,
  chunksLen: number,
): boolean {
  const actual = reportStore[reportId]?.chunks.length ?? 0;
  return actual === chunksLen;
}

- if (order.status !== OrderStatus.CANCELED) {
-   await cancelOrder(order.id);
- }

+ if (order.status === OrderStatus.CREATED) {
+   await cancelOrder(order.id);
+ } else if (order.status === OrderStatus.CANCELED) {
+   return order;
+ } else {
+   throw new BusinessError("当前订单状态不允许取消");
+ }