job51-gitlab-cr-node-jt-1 2.7.3 → 2.7.5

package/.claude/rules/code-review-rules.md

@@ -47,7 +47,37 @@
        >   - **仅在校验风格与同一文件中其他接口明显不一致时**，才需要提示
 
 0. **Diff 数据结构与上下文读取规则**：
-> - **临时文件格式说明**：
+> - **⚠️ 重要变更：按文件合并审查（多块临时文件）**：
+    >   - **临时文件可能包含同一文件的多个变更块**（解决了"同一方法被拆分成多个块"的问题）
+    >   - **临时文件格式**：每个块有明确的边界标识和行号信息
+    >   - **格式示例**：
+        ```
+        # ===== 文件: UserService.java =====
+        # 变更块总数: 2
+        
+        # ===== 变更块 0 =====
+        # 行号范围: 10 - 15
+        # New Start: 10
+        # New Count: 6
+        # 行号计算: 此块内第1行代码 = 10, 每往下一行行号+1
+        
+        [上下文代码]
+        + if (obj == null) return;  ← 判空逻辑（块0）
+        
+        # ===== 变更块 1 =====
+        # 行号范围: 50 - 53
+        # New Start: 50
+        # New Count: 4
+        
+        [上下文代码]
+        + obj.getXxx();  ← 使用逻辑（块1）
+        
+        # ===== 文件信息总结 =====
+        # ⚠️ 行号计算规则：找到问题所在块，从该块第1行代码开始计数
+        ```
+    >   - **关键改进**：AI 能看到同一文件的所有变更块（块0判空 + 块1使用），**避免误报 NPE**
+
+> - **临时文件格式说明（旧版兼容）**：
     >   - 文件分为两部分：`=== File Information ===` 和 `=== Diff Content ===`
     >   - **File Information 部分**：
     >     - `New Path`: 变更后的文件路径，格式如 `b/src/main/java/com/example/UserService.java`

package/.claude/skills/simple-code-review/SKILL.md

@@ -7,47 +7,77 @@ description: 代码审查技能，审查变更代码并输出 REPORT 和 LINE_IN
 
 1. **读取 diff 文件**：使用 Read 工具读取文件：$ARGUMENTS
 
-2. **解析文件信息**：从文件末尾的 `# File Information` 部分提取
-   - `New Start`: 当前 diff 块在变更后文件中的起始行号
-   - `New Count`: 当前 diff 块的行数
-   - `New Path`: 文件路径（去掉 `a/` 或 `b/` 前缀）
-   - **注意**：元数据在文件末尾，`@@` 行已被移除，不影响行号计数
-
-3. **解析行号**：**基于 diff 块内容逐行计数，计算绝对行号**
-   - **行号计算方法**：
-     1. 从元数据中读取 `New Start` 值
+2. **识别临时文件类型**（关键步骤）：
+   - **类型 A：多块合并文件**（新格式，推荐）
+     - 文件开头有 `# ===== 文件: [文件名] =====`
+     - 包含多个 `# ===== 变更块 N =====` 标记
+     - 每个块有独立的 `# New Start`、`# New Count`、`# 行号范围` 信息
+     - **示例格式**：
+       ```
+       # ===== 文件: UserService.java =====
+       # 变更块总数: 2
+
+       # ===== 变更块 0 =====
+       # 行号范围: 10 - 15
+       # New Start: 10
+       # New Count: 6
+       [上下文代码]
+       + if (obj == null) return;  ← 判空逻辑（块0）
+
+       # ===== 变更块 1 =====
+       # 行号范围: 50 - 53
+       # New Start: 50
+       # New Count: 4
+       [上下文代码]
+       + obj.getXxx();  ← 使用逻辑（块1）
+
+       # ===== 文件信息总结 =====
+       # ⚠️ 行号计算规则：找到问题所在块，从该块第1行代码开始计数
+       ```
+     - **关键优势**：能看到同一文件的所有变更块（块0判空 + 块1使用），**避免误报 NPE**
+
+   - **类型 B：单块文件**（旧格式，兼容）
+     - 文件末尾有 `# File Information` 部分
+     - 只包含一个 diff 块的内容
+     - 从 `# New Start` 和 `# New Count` 提取行号信息
+
+3. **解析行号**（多块文件的关键规则）：
+   - **⚠️ 多块文件的行号计算方法**：
+     1. **识别问题所在的块**：通过 `# ===== 变更块 N =====` 标记
+     2. **读取该块的 New Start 值**：从块开头的 `# New Start: X` 提取
+     3. **从该块第1行代码开始计数**：行号 = New Start
+     4. **每往下一行（+ 或空格开头），行号 +1**
+     5. **- 开头的删除行不计数**，行号不增加
+     6. **示例**：
+        - 问题在"变更块 1"，该块 `# New Start: 50`
+        - 从块内第1行代码开始计数，第2行是 `obj.getXxx()`
+        - 行号 = 50 + 1 = 51
+     7. **⚠️ 强制验证**：输出前必须检查行号是否在该块范围内 `[New Start, New Start + New Count - 1]`
+
+   - **单块文件的行号计算方法**（旧格式兼容）：
+     1. 从文件末尾 `# File Information` 提取 `New Start` 和 `New Count`
      2. 从第 1 行代码开始，行号 = `New Start`
-     3. 每往下一行（`+` 开头或空格开头），行号 +1
-     4. `-` 开头的删除行**不计数**，行号不增加
-     5. 示例：`New Start: 1` 时，第 1 行代码行号=1，第 2 行行号=2，以此类推
-   - **忽略元数据行**：文件末尾的 `# File Information` 等以 `# ` 开头的行都**不编号**，直接跳过
-   - **⚠️ 临时文件格式示例**（理解计数起点）：
-     ```
-     [代码行 1]                     <-- 空格开头，行号 = 29（New Start=29）
-     + [代码行 2]                   <-- + 开头，行号 = 30（29+1）
-     + [代码行 3]                   <-- + 开头，行号 = 31（30+1）
-     [代码行 4]                     <-- 空格开头，行号 = 32（31+1）
-     ...（diff 内容结束）
-     # File Information
-     # New Path: b/src/Test.java
-     # New Start: 29                <-- 元数据在末尾，提供行号计算起点
-     ```
-   - **⚠️ 强制验证步骤**（输出前必须执行）：
-     1. 从元数据提取 `New Start` 和 `New Count`，计算行号范围：`[New Start, New Start + New Count - 1]`
+     3. 每往下一行（`+` 或空格开头），行号 +1
+     4. `-` 开头的删除行不计数
+     5. 验证行号范围 `[New Start, New Start + New Count - 1]`
+
+   - **⚠️ 强制验证步骤**（所有文件类型必须执行）：
+     1. 从元数据提取 `New Start` 和 `New Count`，计算行号范围
      2. **逐个检查**每个问题的行号是否在该范围内
      3. **如果任何行号超出范围，必须重新计数**
      4. **禁止**直接使用从完整文件读取的行号
-   - **示例**：
-     - `New Start: 1, New Count: 56` 的行号范围是 [1, 56]，**不能返回 57、60 等超出范围的值**
-     - `New Start: 167, New Count: 6` 的行号范围是 [167, 172]，**不能返回 <167 或 >172 的值**
 
 4. **读取上下文**：基于 New Path 读取变更后文件，涉及方法调用时追踪读取实现代码
    - **⚠️ 重要**：读取完整文件仅用于理解代码逻辑，**不得**直接使用完整文件中的行号
    - 如果从完整文件中定位到问题行号，**必须验证**该行号是否在 diff 块范围内
    - **验证公式**：`new_start <= 行号 <= new_start + new_count - 1`
-   - **如果行号超出范围**：必须回到 diff 块内容，重新基于 `@@` 头之后逐行计数
+   - **如果行号超出范围**：必须回到 diff 块内容，重新逐行计数
 
 5. **执行审查**：按照 @.claude/rules/code-review-rules.md 中的规则进行审查
+   - **⚠️ 多块文件的审查优势**：
+     - 能看到同一文件的所有变更块（块0判空 + 块1使用）
+     - **避免误报"块1未判空"**（因为能看到块0已有判空）
+     - **跨块上下文分析**：合并同一文件多个块的信息，判断逻辑是否安全
 
 6. **输出结果**：
    - 审查结果放入 `<REPORT>` 标签

package/docs/GITLAB_CR_NODE_TECHNICAL_DOCS.md

@@ -1,9 +1,9 @@
 # GitLab Code Review AI Tool 技术文档
 
 **项目名称**: job51-gitlab-cr-node  
-**当前版本**: 2.6.11  
+**当前版本**: 2.7.4  
 **作者**: tao.jing  
-**最后更新**: 2026-04-17  
+**最后更新**: 2026-04-20  
 **项目地址**: https://gitdev.51job.com/51jobweb/ai-agent  
 
 ---
@@ -27,6 +27,50 @@
 
 ## 版本历史
 
+### v2.7.4 (2026-04-20)
+
+**当前版本**: 日志标识增强
+
+**优化**:
+- **日志追踪标识**：为每个 diff 块的 AI 调用添加唯一标识，解决 CI 环境中处理多个 diff 块重试时日志追踪困难的问题
+  - 问题现象：当某个 diff 块需要重试时，日志中无法清晰识别是哪个块的输出
+  - 修复方案：
+    - 在 `processBlock` 函数中构造块标识：`文件路径#块索引`（如 `UserService.java#0`）
+    - 将标识传递给 `reviewDiffWithClaudeUsingFile` 方法
+    - 更新所有关键日志输出，添加 `[块标识]` 前缀
+  - 影响范围：
+    - 所有 AI 调用的日志（开始审核、重试、完成、决策判断等）
+    - LINE_INFO 检查、严重问题检查、标题验证等关键决策点的日志
+  - 修复文件：
+    - `index.js:110-112`：构造块标识并传递给审查方法
+    - `index.js:182-183`：添加 `blockIdentifier` 参数
+    - `index.js:202-274`：更新所有日志输出添加标识前缀
+
+### v2.7.3 (2026-04-17)
+
+**优化**:
+- **技术文档版本同步**：更新文档版本号与 package.json 保持一致
+
+### v2.7.2 (2026-04-17)
+
+**优化**:
+- **技术文档版本同步**：更新文档版本号与 package.json 保持一致
+
+### v2.7.1 (2026-04-17)
+
+**优化**:
+- **技能文件优化**：更新 simple-code-review 技能定义，简化行号计算说明
+
+### v2.7.0 (2026-04-17)
+
+**功能增强**:
+- **审查流程优化**：改进代码审查逻辑和行号计算准确性
+
+### v2.6.12 (2026-04-17)
+
+**优化**:
+- **版本发布准备**：更新项目版本号和文档
+
 ### v2.6.11 (2026-04-17)
 
 **Bug 修复**:

package/index.js

@@ -63,79 +63,129 @@ class GitLabCodeReviewer {
     // 开始审查统计
     this.metrics.startReview();
 
-    // 获取diff信息
+    // 获取diff信息（每个 diff 对应一个文件的变更）
     const diffs = await this.getMergeRequestDiffs(projectId, mergeRequestIid);
-    debugLog(`获取到 ${diffs.length} 个diff块`);
+    debugLog(`获取到 ${diffs.length} 个文件变更`);
 
-    // 对每个diff进一步按变更块拆分并审核
-    debugLog('开始处理所有diff块的变更块拆分');
+    // 按文件分组所有块（关键改进：同一文件的所有块合并审查）
+    debugLog('开始按文件分组所有变更块');
+    const fileBlocksMap = new Map();  // 文件路径 → 所有块数组
 
-    // 创建处理单个块的函数
-    const processBlock = async (diffObject, blockIndex) => {
-      // 创建临时文件存储diff内容，文件地址选择当前文件夹下，避免权限问题
-      const fileName = `temp-diff-block-${Date.now()}-${blockIndex}.diff`;
+    for (const diff of diffs) {
+      const diffObjects = this.getDiffBlocks(diff);
+      const filePath = diff.new_path || diff.old_path;
+
+      if (!fileBlocksMap.has(filePath)) {
+        fileBlocksMap.set(filePath, []);
+      }
+
+      // 为每个块分配全局块索引（文件内唯一）
+      const existingBlocks = fileBlocksMap.get(filePath);
+      for (let i = 0; i < diffObjects.length; i++) {
+        diffObjects[i].block_index = existingBlocks.length + i;
+        existingBlocks.push(diffObjects[i]);
+      }
+    }
+
+    debugLog(`分组完成：共 ${fileBlocksMap.size} 个文件，包含 ${Array.from(fileBlocksMap.values()).reduce((sum, blocks) => sum + blocks.length, 0)} 个变更块`);
+
+    // 打印每个文件的块数（用于调试）
+    for (const [filePath, blocks] of fileBlocksMap.entries()) {
+      debugLog(`文件 ${filePath}: ${blocks.length} 个变更块`);
+      blocks.forEach((block, i) => {
+        debugLog(`  - 块 ${block.block_index}: new_start=${block.line_info?.new_start}, new_count=${block.line_info?.new_count}`);
+      });
+    }
+
+    // 创建处理单个文件的函数（替代原来的 processBlock）
+    const processFile = async (filePath, blocks) => {
+      // 创建临时文件存储该文件的所有变更块
+      const fileName = `temp-diff-file-${Date.now()}-${filePath.replace(/[\/\\]/g, '_')}.diff`;
       const tmpFileName = path.join(process.cwd(), fileName);
 
       try {
-        // 打印 diff 块完整信息（用于调试行号问题）
-        debugLog(`========== Diff Block ${blockIndex} 开始 ==========`);
-        debugLog(`文件路径：${diffObject.new_path || diffObject.old_path}`);
-        debugLog(`line_info: old_start=${diffObject.line_info?.old_start}, old_count=${diffObject.line_info?.old_count}, new_start=${diffObject.line_info?.new_start}, new_count=${diffObject.line_info?.new_count}`);
-        debugLog(`diff 内容：${diffObject.diff}`);
-        debugLog(`========== Diff Block ${blockIndex} 结束 ==========`);
-
-        // 解析 diff 内容，移除 @@ 行，将其信息放入元数据
-        // 这样 AI 不会把 @@ 行误计数
-        const diffLines = diffObject.diff.split('\n');
-        const codeLines = diffLines.filter(line => !line.startsWith('@@')).join('\n');
-
-        // 构造临时文件内容：纯代码在前，元数据在后
-        const diffContentWithMetadata = `${codeLines}
-
-# File Information
-# New Path: ${diffObject.new_path || 'N/A'}
-# New Start: ${diffObject.line_info?.new_start || 1}
-# New Count: ${diffObject.line_info?.new_count || 1}
-# 行号计算：从第 1 行代码开始计数，第 1 行行号=NewStart，每往下一行行号 +1，#开头的元数据行不计数`;
-
-        // 将diff内容写入临时文件
-        fs.writeFileSync(tmpFileName, diffContentWithMetadata);
-
-        // 输出临时文件前 10 行用于调试（确认元数据格式）
-        const tmpFileLines = diffContentWithMetadata.split('\n').slice(0, 10).join('\n');
-        debugLog(`临时文件前 10 行预览:\n${tmpFileLines}`);
-
-        // 审核当前块（传入临时的文件而不是直接的diff内容）
-        const blockStartTime = Date.now();
-        const review_result = await this.reviewDiffWithClaudeUsingFile(tmpFileName);
-        const blockObj = { ...diffObject, review_result, temp_file_path: tmpFileName };
-        // 记录审查指标
-        const reviewTime = Date.now() - blockStartTime;
-        const hasSeriousProblems = blockObj.review_result && blockObj.review_result.reportContent && blockObj.review_result.reportContent.includes('严重问题');
-        const problemsCount = hasSeriousProblems ? 1 : 0; // 简化计算，实际可以更复杂
-        const diffSize = diffObject.diff?.length || 0;
-        const filePath = diffObject.new_path || diffObject.old_path || '';
-        this.metrics.recordBlockReviewed(reviewTime, problemsCount, hasSeriousProblems, diffSize, filePath);
-
-        // 检查审查结果中是否包含严重问题，只有包含严重问题才发布评论
-        if (blockObj.review_result && blockObj.review_result.reportContent && blockObj.review_result.reportContent.includes('严重问题')) {
-          // 立即发布评论
-          await this.postSingleCommentToGitLab(projectId, mergeRequestIid, {
-            diff_info: blockObj,
-            block_index: blockObj.block_index,
-            review_result: blockObj.review_result,
-          });
+        debugLog(`========== 文件审查开始: ${filePath} ==========`);
+        debugLog(`文件包含 ${blocks.length} 个变更块`);
+
+        // 构建包含所有块的临时文件内容
+        const fileDiffContent = this.buildFileDiffContent(filePath, blocks);
+        fs.writeFileSync(tmpFileName, fileDiffContent);
+
+        // 输出临时文件前 20 行用于调试
+        const tmpFilePreview = fileDiffContent.split('\n').slice(0, 20).join('\n');
+        debugLog(`临时文件前 20 行预览:\n${tmpFilePreview}`);
+
+        // 审查整个文件的所有变更（能看到完整上下文）
+        const fileStartTime = Date.now();
+        const fileIdentifier = filePath;
+        const review_result = await this.reviewDiffWithClaudeUsingFile(tmpFileName, fileIdentifier);
+        const reviewTime = Date.now() - fileStartTime;
+
+        // 记录审查指标（按文件记录，而不是按块）
+        const hasSeriousProblems = review_result && review_result.reportContent && review_result.reportContent.includes('严重问题');
+        const totalDiffSize = blocks.reduce((sum, block) => sum + (block.diff?.length || 0), 0);
+        this.metrics.recordFileReviewed();
+        blocks.forEach(block => {
+          const blockProblemsCount = hasSeriousProblems ? 1 : 0;
+          this.metrics.recordBlockReviewed(reviewTime / blocks.length, blockProblemsCount, hasSeriousProblems, block.diff?.length || 0, filePath);
+        });
+
+        // 解析所有问题的行号信息
+        const allLineInfo = this.parseAllLineInfoFromReviewResult(review_result?.lineInfo);
+        debugLog(`解析到 ${allLineInfo.length} 个问题的行号信息`);
+
+        // 检查审查结果中是否包含严重问题
+        if (hasSeriousProblems && allLineInfo.length > 0) {
+          debugLog(`文件 ${filePath} 包含 ${allLineInfo.length} 个严重问题，开始发布评论`);
+
+          // 为每个问题发布评论
+          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(review_result.reportContent, i + 1);
+
+            // 找到对应的块信息（根据行号范围匹配）
+            const matchedBlock = blocks.find(block => {
+              const newStart = block.line_info?.new_start || 1;
+              const newCount = block.line_info?.new_count || 1;
+              const newEnd = newStart + newCount - 1;
+              return problemInfo.new_line >= newStart && problemInfo.new_line <= newEnd;
+            });
+
+            if (!matchedBlock) {
+              debugLog(`警告：问题行号 ${problemInfo.new_line} 无法匹配到任何块，发布为一般讨论`);
+              await this.createGeneralDiscussion(projectId, mergeRequestIid, `${filePath}#L${problemInfo.new_line}`, singleProblemContent);
+              this.metrics.recordCommentPublished();
+              continue;
+            }
+
+            // 发布评论到对应块
+            await this.postSingleCommentToGitLab(projectId, mergeRequestIid, {
+              diff_info: matchedBlock,
+              block_index: matchedBlock.block_index,
+              review_result: {
+                reportContent: singleProblemContent,
+                lineInfo: `<LINE_INFO>[${JSON.stringify(problemInfo)}]</LINE_INFO>`
+              },
+            });
+            this.metrics.recordCommentPublished();
+          }
         } else {
-          debugLog(`该块不包含严重问题，跳过评论发布: ${blockObj.new_path || blockObj.old_path}#${blockObj.block_index}`);
+          debugLog(`文件 ${filePath} 不包含严重问题，跳过评论发布`);
         }
 
+        debugLog(`========== 文件审查完成: ${filePath} ==========`);
+
         return {
-          diff_info: blockObj,
-          block_index: blockObj.block_index,
-          review_result: blockObj.review_result,
+          file_path: filePath,
+          blocks_count: blocks.length,
+          review_result,
           temp_file_path: tmpFileName,
         };
       } catch (error) {
+        console.error(`文件 ${filePath} 审查失败:`, error.message);
         throw error;
       } finally {
         try {
@@ -148,23 +198,13 @@ class GitLabCodeReviewer {
       }
     };
 
-    // 收集所有需要处理的块
-    const allBlocks = [];
-    for (const diff of diffs) {
-      const diffObjects = this.getDiffBlocks(diff);
-      for (let i = 0; i < diffObjects.length; i++) {
-        // 更新块索引
-        diffObjects[i].block_index = i;
-        allBlocks.push({ diffObject: diffObjects[i], blockIndex: i });
-      }
-    }
-
-    // 使用线程池控制并发数量
-    const results = await this.processWithThreadPool(allBlocks, processBlock, maxConcurrency);
+    // 使用线程池控制并发数量（按文件并发，而不是按块）
+    const fileTasks = Array.from(fileBlocksMap.entries()).map(([filePath, blocks]) => ({ filePath, blocks }));
+    const results = await this.processWithThreadPool(fileTasks, (task) => processFile(task.filePath, task.blocks), maxConcurrency);
 
-    debugLog(`总共处理了 ${results.length} 个diff block块`);
+    debugLog(`总共处理了 ${results.length} 个文件`);
 
-    debugLog('所有diff块审核并发布评论完成');
+    debugLog('所有文件审核并发布评论完成');
     // 结束审查统计
     this.metrics.endReview();
 
@@ -174,10 +214,11 @@ class GitLabCodeReviewer {
   /**
    * 使用Claude对单个diff文件进行代码审核
    * @param {string} filePath 临时文件路径
+   * @param {string} blockIdentifier 块标识（格式：文件路径#块索引），用于日志追踪
    * @returns {Promise<string>} 审核结果
    */
-  async reviewDiffWithClaudeUsingFile(filePath) {
-    debugLog(`开始审核文件: ${filePath}`);
+  async reviewDiffWithClaudeUsingFile(filePath, blockIdentifier = 'unknown') {
+    debugLog(`[${blockIdentifier}] 开始审核文件: ${filePath}`);
     const startTime = Date.now();
 
     const prompt = `请调用 simple-code-review 技能审核代码变更。
@@ -196,7 +237,7 @@ class GitLabCodeReviewer {
 4. **必须输出 '<LINE_INFO>' 标签**，包含所有问题的行号信息（无问题时输出空数组 [])
 5. 不要输出任何额外的解释、问候或总结文本`;
     //打印
-    debugLog(`Claude命令: ${prompt}`);
+    debugLog(`[${blockIdentifier}] Claude命令: ${prompt}`);
     // 最多重试5次，直到结果包含"🤖 AI 代码审查结果"或达到最大重试次数
     let attempts = 0;
     const maxAttempts = 5;
@@ -205,20 +246,20 @@ class GitLabCodeReviewer {
     while (attempts < maxAttempts) {
       attempts++;
       try {
-        debugLog(`调用本地AI命令审核文件 (尝试 ${attempts}/${maxAttempts})`);
+        debugLog(`[${blockIdentifier}] 调用本地AI命令审核文件 (尝试 ${attempts}/${maxAttempts})`);
 
         // 直接将prompt内容（包含文件路径）传递给Claude命令
         claudeResult = await runClaudeCommand(prompt);
         //若结果为空，则记录日志
         if (!claudeResult) {
-          debugLog(`本地AI命令审核结果为空`);
+          debugLog(`[${blockIdentifier}] 本地AI命令审核结果为空`);
           return { reportContent: '<REPORT>\n## 🤖 AI 代码审查结果\n\n</REPORT>', lineInfo: '[]' };
         }
-        debugLog(`本地 AI 命令审核完成，审核结果长度：${claudeResult?.length || 0}`);
+        debugLog(`[${blockIdentifier}] 本地 AI 命令审核完成，审核结果长度：${claudeResult?.length || 0}`);
 
         // 打印报告内容前 500 字符（避免过长）
         const reportPreview = claudeResult?.length > 500 ? claudeResult.substring(0, 500) + '...' : claudeResult;
-        debugLog(`AI 审核报告内容预览：${claudeResult}`);
+        debugLog(`[${blockIdentifier}] AI 审核报告内容预览：${claudeResult}`);
 
         // 使用正则提取 LINE_INFO 内容（支持换行）
         const lineInfoMatch = claudeResult?.match(/<LINE_INFO>\s*\[([^\]]*)\]\s*<\/LINE_INFO>/);
@@ -228,11 +269,11 @@ class GitLabCodeReviewer {
         const lineInfoContent = hasLineInfoTag ? lineInfoMatch[1].replace(/\s/g, '') : '';
         const hasNonEmptyLineInfo = hasLineInfoTag && lineInfoContent !== '';
 
-        debugLog(`LINE_INFO 检查结果：hasLineInfoTag=${hasLineInfoTag}, hasNonEmptyLineInfo=${hasNonEmptyLineInfo}, lineInfoContent=[${lineInfoContent}]`);
+        debugLog(`[${blockIdentifier}] LINE_INFO 检查结果：hasLineInfoTag=${hasLineInfoTag}, hasNonEmptyLineInfo=${hasNonEmptyLineInfo}, lineInfoContent=[${lineInfoContent}]`);
 
         // LINE_INFO 为空或不存在 → 说明无问题，直接返回标准空格式
         if (!hasLineInfoTag || !hasNonEmptyLineInfo) {
-          debugLog(`【决策】LINE_INFO 为空或不存在，说明无问题，直接返回标准空格式`);
+          debugLog(`[${blockIdentifier}] 【决策】LINE_INFO 为空或不存在，说明无问题，直接返回标准空格式`);
           return { reportContent: '<REPORT>\n## 🤖 AI 代码审查结果\n\n</REPORT>', lineInfo: '[]' };
         }
 
@@ -240,32 +281,32 @@ class GitLabCodeReviewer {
         // 先检查是否有严重问题（放宽匹配，只检查"严重问题"关键词）
         const hasSeriousProblem = claudeResult && claudeResult.includes('严重问题');
 
-        debugLog(`严重问题检查：hasSeriousProblem=${hasSeriousProblem}`);
+        debugLog(`[${blockIdentifier}] 严重问题检查：hasSeriousProblem=${hasSeriousProblem}`);
 
         // 无严重问题 → 直接返回标准空格式
         if (!hasSeriousProblem) {
-          debugLog(`【决策】报告无严重问题，返回标准空格式`);
+          debugLog(`[${blockIdentifier}] 【决策】报告无严重问题，返回标准空格式`);
           return { reportContent: '<REPORT>\n## 🤖 AI 代码审查结果\n\n</REPORT>', lineInfo: '[]' };
         }
 
         // 有严重问题 → 检查标题是否符合要求
         const hasValidTitle = claudeResult && claudeResult.includes('🤖 AI 代码审查结果');
 
-        debugLog(`标题检查：hasValidTitle=${hasValidTitle}`);
+        debugLog(`[${blockIdentifier}] 标题检查：hasValidTitle=${hasValidTitle}`);
 
         if (hasValidTitle) {
-          debugLog(`【决策】报告包含严重问题且标题正确，接受结果 (尝试 ${attempts})`);
+          debugLog(`[${blockIdentifier}] 【决策】报告包含严重问题且标题正确，接受结果 (尝试 ${attempts})`);
           return extractReportContent(claudeResult);
         }
 
         // 有严重问题但标题不符合 → 重试
-        debugLog(`【决策】报告包含严重问题但标题不符合要求 (尝试 ${attempts})，将重试...`);
+        debugLog(`[${blockIdentifier}] 【决策】报告包含严重问题但标题不符合要求 (尝试 ${attempts})，将重试...`);
         if (attempts >= maxAttempts) {
-          debugLog(`【决策】已达到最大重试次数 ${maxAttempts}，返回最后一次结果`);
+          debugLog(`[${blockIdentifier}] 【决策】已达到最大重试次数 ${maxAttempts}，返回最后一次结果`);
           return extractReportContent(claudeResult);
         }
       } catch (error) {
-        console.error(`AI审核失败 (尝试 ${attempts}/${maxAttempts}):`, error.message);
+        console.error(`[${blockIdentifier}] AI审核失败 (尝试 ${attempts}/${maxAttempts}):`, error.message);
         if (attempts >= maxAttempts) {
           return `审核失败: ${error.message}`;
         }
@@ -275,6 +316,60 @@ class GitLabCodeReviewer {
     }
   }
 
+  /**
+   * 构建包含文件所有变更块的临时文件内容
+   * @param {string} filePath 文件路径
+   * @param {Array} blocks 该文件的所有变更块
+   * @returns {string} 临时文件内容
+   */
+  buildFileDiffContent(filePath, blocks) {
+    let content = '';
+
+    // 文件头部信息
+    content += `# ===== 文件: ${filePath} =====\n`;
+    content += `# 变更块总数: ${blocks.length}\n\n`;
+
+    // 遍历每个块，标注块边界和行号信息
+    for (let i = 0; i < blocks.length; i++) {
+      const block = blocks[i];
+      const newStart = block.line_info?.new_start || 1;
+      const newCount = block.line_info?.new_count || 1;
+      const newEnd = newStart + newCount - 1;
+
+      // 块分隔标记
+      content += `# ===== 变更块 ${block.block_index} =====\n`;
+      content += `# 行号范围: ${newStart} - ${newEnd}\n`;
+      content += `# New Start: ${newStart}\n`;
+      content += `# New Count: ${newCount}\n`;
+      content += `# 行号计算: 此块内第1行代码 = ${newStart}, 每往下一行行号+1\n`;
+      content += `# ⚠️ 重要: -开头的删除行不计数，行号不增加\n\n`;
+
+      // 解析并添加块内容（移除 @@ 行）
+      const diffLines = block.diff.split('\n');
+      const codeLines = diffLines.filter(line => !line.startsWith('@@'));
+
+      // 添加代码行（保留 +、-、空格前缀）
+      content += codeLines.join('\n');
+      content += '\n\n';
+    }
+
+    // 文件尾部元数据
+    content += `# ===== 文件信息总结 =====\n`;
+    content += `# 文件路径: ${filePath}\n`;
+    content += `# 变更块数量: ${blocks.length}\n`;
+    blocks.forEach(block => {
+      content += `# - 块 ${block.block_index}: 行号 ${block.line_info?.new_start}-${block.line_info?.new_start + (block.line_info?.new_count || 1) - 1}\n`;
+    });
+    content += `# ⚠️ 行号计算规则：\n`;
+    content += `# 1. 找到问题所在块（根据块边界标识）\n`;
+    content += `# 2. 从该块第1行代码开始计数，行号 = New Start\n`;
+    content += `# 3. 每往下一行（+开头或空格开头），行号+1\n`;
+    content += `# 4. -开头的删除行不计数，行号不增加\n`;
+    content += `# 5. 输出前验证：行号必须在对应块范围内 [New Start, New Start + New Count - 1]\n`;
+
+    return content;
+  }
+
   /**
    * 使用线程池控制并发执行
    * @param {Array} tasks 任务数组
@@ -291,8 +386,8 @@ class GitLabCodeReviewer {
     for (let i = 0; i < tasks.length; i++) {
       const task = tasks[i];
 
-      // 创建一个异步任务
-      const promise = processor(task.diffObject, task.blockIndex)
+      // 创建一个异步任务（直接传递 task 对象，不再拆分参数）
+      const promise = processor(task)
         .then(result => {
           results.push(result);
           // 从执行队列中移除已完成的任务

package/package.json

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