job51-gitlab-cr-node-jt-1 2.9.1 → 2.9.3

package/docs/GITLAB_CR_NODE_TECHNICAL_DOCS.md

@@ -1,9 +1,9 @@
 # GitLab Code Review AI Tool 技术文档
 
-**项目名称**: job51-gitlab-cr-node  
-**当前版本**: 2.8.7  
-**作者**: tao.jing  
-**最后更新**: 2026-04-28  
+**项目名称**: job51-gitlab-cr-node
+**当前版本**: 2.8.8
+**作者**: tao.jing
+**最后更新**: 2026-05-09
 **项目地址**: https://gitdev.51job.com/51jobweb/ai-agent  
 
 ---
@@ -27,6 +27,56 @@
 
 ## 版本历史
 
+### v2.8.8 (2026-05-09)
+
+**当前版本**: 幻觉检测增强 - 部分幻觉问题过滤机制
+
+**新增功能**:
+- **部分幻觉问题过滤机制**：在汇总报告中只显示正常发布的问题，不包含幻觉问题内容
+  - 问题现象：当一个diff块有多个问题时，部分问题被检测为幻觉（如文件路径不匹配），但汇总报告中仍包含所有问题的完整内容，包括幻觉问题的内容
+  - 根本原因：
+    - 幻觉检测逻辑只判断是否跳过评论发布
+    - 但审查结果的 `reportContent` 包含所有问题的完整报告
+    - 汇总报告直接使用原始 `reportContent`，导致幻觉问题内容也被显示
+  - 影响分析：
+    - 用户在汇总报告中看到幻觉问题的内容，但这些问题的评论并未发布到GitLab
+    - 产生信息不一致，降低汇总报告的可信度
+  - 解决方案：
+    - **统计机制**：记录每个问题的发布状态（幻觉/正常）
+    - **过滤机制**：根据实际发布的问题索引重新生成过滤后的报告内容
+    - **传递机制**：通过返回值将过滤后的内容传递给汇总报告生成流程
+  - 实现细节：
+    - 新增 `publishedProblemIndexes` 数组：记录正常发布的问题索引（从1开始）
+    - 新增 `generateFilteredReport` 方法：根据问题索引生成过滤后的报告内容
+    - 修改 `postSingleCommentToGitLab` 方法：
+      - 统计幻觉问题数量和正常发布数量
+      - 根据统计结果返回不同状态：
+        - 所有问题都是幻觉：返回 `{ hallucination_detected: true, filtered_report_content: '' }`
+        - 部分问题正常：返回 `{ hallucination_detected: false, filtered_report_content: '过滤后的报告' }`
+        - 所有问题正常：返回 `{ hallucination_detected: false, filtered_report_content: '完整报告' }`
+    - 修改 `processBlock` 方法：接收过滤后的报告内容并更新 `blockObj.review_result.reportContent`
+    - 修改 `collectAllReviewReports` 方法：过滤掉完全幻觉的结果
+  - 处理场景：
+    - **场景1：所有问题都是幻觉**
+      - 示例：问题1、2、3文件路径都不匹配
+      - 行为：标记为幻觉，过滤掉整个结果，不出现在汇总报告中
+    - **场景2：部分问题正常**
+      - 示例：问题1幻觉（文件路径不匹配），问题2、3正常发布
+      - 行为：不标记为幻觉，但汇总报告只显示问题2、3的内容（过滤掉问题1）
+      - 实现：调用 `generateFilteredReport` 提取问题2、3内容
+    - **场景3：所有问题都正常**
+      - 示例：问题1、2、3都正常发布
+      - 行为：汇总报告显示完整内容
+  - 效果：
+    - 汇总报告与GitLab发布的评论保持一致
+    - 用户看到的汇总报告内容都是实际发布的评论内容
+    - 提高汇总报告的准确性和可信度
+  - 修复文件：
+    - `index.js:863-966`：统计机制和返回值增强
+    - `index.js:125-147`：接收过滤后的内容并更新报告
+    - `index.js:201-223`：汇总报告过滤逻辑
+    - `index.js:775-807`：新增 `generateFilteredReport` 方法
+
 ### v2.8.7 (2026-04-29)
 
 **当前版本**: 审查规则增强 - 文件路径格式保留与上下文行限制
@@ -1300,7 +1350,9 @@ POST /projects/{projectId}/merge_requests/{iid}/notes
 
 ## 10. 错误处理与容错机制
 
-### 10.1 AI 幻觉检测与过滤 (v2.8.4)
+### 10.1 AI 幻觉检测与过滤
+
+#### 10.1.1 文件路径幻觉检测 (v2.8.4)
 
 **幻觉问题表现**:
 - AI 在生成审查报告时可能编造错误的文件路径
@@ -1317,18 +1369,97 @@ if (problemInfo.new_path && diff_info.new_path &&
 }
 ```
 
-**处理策略**:
-| 检测到幻觉时 | 处理动作 | 结果 |
-|------------|----------|------|
-| 文件路径不匹配 | 输出警告日志 + `continue`跳过 | **不发布评论**，避免误导 |
-| 行号超出范围 | 降级为一般讨论 | 发布到 MR（无行号定位） |
-| GitLab API失败 | 降级为一般讨论 | 确保评论可见 |
-
-**效果**:
-- ✅ 防止错误路径的评论发布
-- ✅ 提高审查准确性
-- ✅ 减少无效评论
-- ✅ 提升用户信任度
+#### 10.1.2 部分幻觉过滤机制 (v2.8.8)
+
+**新增问题**:
+- 一个diff块有多个问题时，部分问题被检测为幻觉，但汇总报告仍包含所有问题的完整内容
+- 用户在汇总报告中看到幻觉问题的内容，但这些评论并未发布到GitLab
+- 信息不一致，降低汇总报告的可信度
+
+**解决方案**:
+
+1. **统计机制**：记录每个问题的发布状态
+```javascript
+// 统计幻觉问题数量和正常发布数量
+let hallucinationCount = 0;
+let publishedCount = 0;
+const publishedProblemIndexes = []; // 记录正常发布的问题索引（从1开始）
+
+for (let i = 0; i < allLineInfo.length; i++) {
+  if (文件路径不匹配) {
+    hallucinationCount++;
+    continue; // 跳过发布
+  }
+  // 正常发布
+  publishedProblemIndexes.push(i + 1);
+  publishedCount++;
+}
+```
+
+2. **过滤机制**：根据问题索引生成过滤后的报告
+```javascript
+// generateFilteredReport 方法：根据问题索引生成过滤后的报告
+generateFilteredReport(fullReport, publishedProblemIndexes) {
+  // 提取报告标题（如 "## 🤖 AI 代码审查结果"）
+  // 提取指定索引的问题内容
+  // 组合成过滤后的报告
+}
+```
+
+3. **传递机制**：返回过滤后的内容
+```javascript
+// 只有问题都被检测为幻觉时，才标记整个结果为幻觉
+const isAllHallucination = hallucinationCount > 0 && hallucinationCount === allLineInfo.length;
+
+if (isAllHallucination) {
+  return { hallucination_detected: true, filtered_report_content: '' };
+}
+
+// 如果部分问题正常发布，生成过滤后的报告内容
+let filteredReportContent = fullReportContent;
+if (publishedCount > 0 && publishedCount < allLineInfo.length) {
+  filteredReportContent = this.generateFilteredReport(fullReportContent, publishedProblemIndexes);
+}
+
+return {
+  hallucination_detected: false,
+  filtered_report_content: filteredReportContent
+};
+```
+
+**处理策略** (v2.8.8更新):
+| 检测场景 | 处理动作 | 汇总报告显示 |
+|---------|----------|------------|
+| 所有问题都是幻觉 | 标记 `hallucination_detected=true` | **完全过滤**，不显示 |
+| 部分问题正常 | 生成过滤后的报告内容 | 只显示正常问题内容 |
+| 所有问题正常 | 返回完整报告内容 | 显示完整内容 |
+
+**效果对比**:
+
+| 版本 | 行为 | 效果 |
+|------|------|------|
+| v2.8.4-v2.8.7 | 所有问题都标记为幻觉 → 过滤整个结果 | ❌ 如果有正常问题，正常问题也被过滤 |
+| v2.8.8 | 只过滤幻觉问题内容，保留正常问题内容 | ✅ 汇总报告与GitLab评论一致 |
+
+**示例**:
+
+假设审查结果有3个问题：
+- 问题1：文件路径不匹配（幻觉）
+- 问题2：正常发布
+- 问题3：正常发布
+
+**v2.8.7处理**:
+```
+hallucination_detected = true
+汇总报告：不显示该diff块
+```
+
+**v2.8.8处理**:
+```
+hallucination_detected = false
+filtered_report_content = 只包含问题2和问题3的内容
+汇总报告：显示问题2和问题3
+```
 
 ### 10.2 AI 审查失败处理
 

package/index.js

@@ -119,14 +119,27 @@ class GitLabCodeReviewer {
         const filePath = diffObject.new_path || diffObject.old_path || '';
         this.metrics.recordBlockReviewed(reviewTime, problemsCount, hasSeriousProblems, diffSize, filePath);
 
+        // 初始化幻觉标记
+        let hallucinationDetected = false;
+
         // 检查审查结果中是否包含严重问题，只有包含严重问题才发布评论
         if (blockObj.review_result && blockObj.review_result.reportContent && blockObj.review_result.reportContent.includes('严重问题')) {
           // 立即发布评论
-          await this.postSingleCommentToGitLab(projectId, mergeRequestIid, {
+          const commentResult = await this.postSingleCommentToGitLab(projectId, mergeRequestIid, {
             diff_info: blockObj,
             block_index: blockObj.block_index,
             review_result: blockObj.review_result,
           });
+          // 如果发布过程中检测到幻觉，记录标记和过滤后的报告
+          if (commentResult) {
+            if (commentResult.hallucination_detected) {
+              hallucinationDetected = true;
+            }
+            // 如果有过滤后的报告内容，使用它替代原始报告内容
+            if (commentResult.filtered_report_content) {
+              blockObj.review_result.reportContent = commentResult.filtered_report_content;
+            }
+          }
         } else {
           debugLog(`该块不包含严重问题，跳过评论发布: ${blockObj.new_path || blockObj.old_path}#${blockObj.block_index}`);
         }
@@ -136,6 +149,7 @@ class GitLabCodeReviewer {
           block_index: blockObj.block_index,
           review_result: blockObj.review_result,
           temp_file_path: tmpFileName,
+          hallucination_detected: hallucinationDetected,
         };
       } catch (error) {
         throw error;
@@ -763,6 +777,50 @@ ${allReportsText}
     return fullReport;
   }
 
+  /**
+   * 根据实际发布的问题索引生成过滤后的报告内容
+   * @param {string} fullReport 完整的 REPORT 内容
+   * @param {Array<number>} publishedProblemIndexes 正常发布的问题索引数组（从 1 开始）
+   * @returns {string} 过滤后的报告内容，只包含正常发布的问题
+   */
+  generateFilteredReport(fullReport, publishedProblemIndexes) {
+    // 提取报告的标题部分（如 "## 🤖 AI 代码审查结果" 和 "### 🔴 严重问题"）
+    const lines = fullReport.split('\n');
+    const headerLines = [];
+    let foundFirstProblem = false;
+
+    for (const line of lines) {
+      // 提取标题行（如 "## 🤖 AI 代码审查结果"、"### 🔴 严重问题" 等）
+      if (line.startsWith('##') || line.startsWith('###')) {
+        if (!line.includes('问题')) {
+          headerLines.push(line);
+        }
+      }
+      // 遇到第一个问题块时停止提取标题
+      if (line.match(/\*\*问题\s*\d+\*\*/)) {
+        foundFirstProblem = true;
+        break;
+      }
+    }
+
+    // 提取每个正常发布的问题内容
+    const filteredProblemBlocks = [];
+    for (const problemIndex of publishedProblemIndexes) {
+      const problemContent = this.extractSingleProblemReport(fullReport, problemIndex);
+      if (problemContent) {
+        filteredProblemBlocks.push(problemContent);
+      }
+    }
+
+    // 组合过滤后的报告：标题 + 问题内容
+    let filteredReport = headerLines.join('\n');
+    if (filteredProblemBlocks.length > 0) {
+      filteredReport += '\n\n' + filteredProblemBlocks.join('\n\n');
+    }
+
+    return filteredReport;
+  }
+
   /**
    * 获取合并请求的最新版本信息
    * @param {number} projectId GitLab项目ID
@@ -849,12 +907,19 @@ ${allReportsText}
       if (allLineInfo.length === 0) {
         await this.createGeneralDiscussion(projectId, mergeRequestIid, file_path_with_line, fullReportContent);
         debugLog(`评论已发布到文件 ${file_path_with_line} (无法解析行号)`);
-        return;
+        return { hallucination_detected: false };
       }
+
+      // 统计幻觉问题数量和正常发布数量
+      let hallucinationCount = 0;
+      let publishedCount = 0;
+      const publishedProblemIndexes = []; // 记录正常发布的问题索引（从1开始）
+
       for (let i = 0; i < allLineInfo.length; i++) {
         const problemInfo = allLineInfo[i];
         debugLog(`处理第 ${i + 1}/${allLineInfo.length} 个问题：文件=${problemInfo.new_path}, 行号=${problemInfo.new_line}`);
-        const singleProblemContent = this.extractSingleProblemReport(fullReportContent, i + 1);
+        const problemIndex = i + 1; // 问题索引从1开始
+        const singleProblemContent = this.extractSingleProblemReport(fullReportContent, problemIndex);
 
         // 构建目标行号，并验证行号是否在 diff 块范围内
         let targetLine = null;
@@ -863,9 +928,8 @@ ${allReportsText}
         // 验证文件路径是否匹配当前 diff 块（检测AI幻觉）
         if (problemInfo.new_path && diff_info.new_path &&
             problemInfo.new_path !== diff_info.new_path) {
-          console.warn(`⚠️  检测到AI幻觉：第 ${i + 1} 个问题的文件路径 ${problemInfo.new_path} 与当前 diff 块文件 ${diff_info.new_path} 不匹配，跳过该问题的评论发布`);
-          // 标记该结果存在幻觉问题，后续生成汇总报告时会过滤掉
-          result.hallucination_detected = true;
+          console.warn(`⚠️  检测到AI幻觉：第 ${problemIndex} 个问题的文件路径 ${problemInfo.new_path} 与当前 diff 块文件 ${diff_info.new_path} 不匹配，跳过该问题的评论发布`);
+          hallucinationCount++;
           continue; // 直接跳过，不发布评论
         }
 
@@ -910,8 +974,8 @@ ${allReportsText}
 
         if (!targetLine) {
           // 无法解析行号或行号超出范围，标记为幻觉问题，跳过发布
-          console.warn(`⚠️  检测到AI幻觉：第 ${i + 1} 个问题 ${skipReason || '无法解析行号'}，该问题可能报告在上下文行或删除行，跳过发布`);
-          result.hallucination_detected = true;
+          console.warn(`⚠️  检测到AI幻觉：第 ${problemIndex} 个问题 ${skipReason || '无法解析行号'}，该问题可能报告在上下文行或删除行，跳过发布`);
+          hallucinationCount++;
           continue;
         }
 
@@ -928,17 +992,41 @@ ${allReportsText}
         };
         try {
           await this.createDiffDiscussion(projectId, mergeRequestIid, payload);
-          debugLog(`第 ${i + 1} 个问题的评论已发布到 ${problemInfo.new_path}#${problemInfo.new_line}`);
+          debugLog(`第 ${problemIndex} 个问题的评论已发布到 ${problemInfo.new_path}#${problemInfo.new_line}`);
           this.metrics.recordCommentPublished();
+          publishedCount++;
+          publishedProblemIndexes.push(problemIndex); // 记录正常发布的问题索引
         } catch (error) {
           debugLog(`GitLab API 错误详情：${JSON.stringify(error.response?.data || error.message)}`);
-          console.error(`发布第 ${i + 1} 个问题的评论到 ${problemInfo.new_path}#${problemInfo.new_line} 失败，改用一般讨论:`, error.message);
+          console.error(`发布第 ${problemIndex} 个问题的评论到 ${problemInfo.new_path}#${problemInfo.new_line} 失败，改用一般讨论:`, error.message);
           await this.createGeneralDiscussion(projectId, mergeRequestIid, file_path_with_line, singleProblemContent);
-          debugLog(`第 ${i + 1} 个问题的评论已发布 (作为一般讨论)`);
+          debugLog(`第 ${problemIndex} 个问题的评论已发布 (作为一般讨论)`);
           this.metrics.recordCommentPublished();
+          publishedCount++;
+          publishedProblemIndexes.push(problemIndex); // 记录正常发布的问题索引
         }
       }
-      debugLog(`所有 ${allLineInfo.length} 个问题的评论已发布完成`);
+      debugLog(`所有 ${allLineInfo.length} 个问题的评论已发布完成，其中幻觉问题 ${hallucinationCount} 个，正常发布 ${publishedCount} 个`);
+
+      // 只有所有问题都被检测为幻觉时，才标记整个结果为幻觉
+      const isAllHallucination = hallucinationCount > 0 && hallucinationCount === allLineInfo.length;
+      if (isAllHallucination) {
+        console.warn(`⚠️  该 diff 块的所有 ${allLineInfo.length} 个问题都被检测为AI幻觉，将过滤该结果`);
+        return { hallucination_detected: true, filtered_report_content: '' };
+      }
+
+      // 如果部分问题正常发布，生成过滤后的报告内容（只包含正常发布的问题）
+      let filteredReportContent = fullReportContent;
+      if (publishedCount > 0 && publishedCount < allLineInfo.length) {
+        console.warn(`⚠️  该 diff 块有 ${hallucinationCount} 个问题被检测为AI幻觉，汇总报告中只保留 ${publishedCount} 个正常发布的问题`);
+        filteredReportContent = this.generateFilteredReport(fullReportContent, publishedProblemIndexes);
+      }
+
+      // 返回幻觉标记和过滤后的报告内容
+      return {
+        hallucination_detected: false,
+        filtered_report_content: filteredReportContent
+      };
     } catch (error) {
       console.error('发布单个评论到 GitLab 失败:', error.message);
       throw error;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "job51-gitlab-cr-node-jt-1",
-  "version": "2.9.1",
+  "version": "2.9.3",
   "description": "GitLab merge request code review tool with AI-powered analysis and project context support",
   "main": "index.js",
   "bin": {

package/.claude/settings.json

@@ -1,10 +0,0 @@
-{
-    "env": {
-        "ANTHROPIC_AUTH_TOKEN": "sk-436f005eeece4cf7b339bd18162c8a76",
-        "ANTHROPIC_BASE_URL": "https://dashscope.aliyuncs.com/apps/anthropic",
-        "API_TIMEOUT_MS": "3000000",
-        "ANTHROPIC_MODEL": "qwen3.5-plus",
-        "ANTHROPIC_SMALL_FAST_MODEL":"qwen3.5-plus",
-        "SLASH_COMMAND_TOOL_CHAR_BUDGET": "50000"
-    }
-}