job51-gitlab-cr-node-jt-1 2.9.0 → 2.9.2

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;
@@ -201,9 +215,13 @@ class GitLabCodeReviewer {
   collectAllReviewReports(results) {
     let allReportsText = '';
 
-    // 遍历所有审查结果
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i];
+    // 遍历所有审查结果，过滤掉检测到幻觉的结果
+    const validResults = results.filter(result => !result.hallucination_detected);
+
+    debugLog(`汇总报告过滤：总共 ${results.length} 个结果，过滤掉 ${results.length - validResults.length} 个幻觉检测结果，保留 ${validResults.length} 个有效结果`);
+
+    for (let i = 0; i < validResults.length; i++) {
+      const result = validResults[i];
       const filePath = result.diff_info.new_path || result.diff_info.old_path;
       const blockIndex = result.block_index;
       const reportContent = result.review_result?.reportContent || '';
@@ -759,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
@@ -845,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;
@@ -859,7 +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} 不匹配，跳过该问题的评论发布`);
+          console.warn(`⚠️  检测到AI幻觉：第 ${problemIndex} 个问题的文件路径 ${problemInfo.new_path} 与当前 diff 块文件 ${diff_info.new_path} 不匹配，跳过该问题的评论发布`);
+          hallucinationCount++;
           continue; // 直接跳过，不发布评论
         }
 
@@ -903,11 +973,9 @@ ${allReportsText}
           }
 
         if (!targetLine) {
-          // 无法解析行号或行号超出范围，使用一般讨论
-          debugLog(`第 ${i + 1} 个问题 ${skipReason || '无法解析行号'}，发布为一般讨论`);
-          await this.createGeneralDiscussion(projectId, mergeRequestIid, file_path_with_line, singleProblemContent);
-          debugLog(`第 ${i + 1} 个问题的评论已发布 (作为一般讨论)`);
-          this.metrics.recordCommentPublished();
+          // 无法解析行号或行号超出范围，标记为幻觉问题，跳过发布
+          console.warn(`⚠️  检测到AI幻觉：第 ${problemIndex} 个问题 ${skipReason || '无法解析行号'}，该问题可能报告在上下文行或删除行，跳过发布`);
+          hallucinationCount++;
           continue;
         }
 
@@ -924,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;