job51-gitlab-cr-node-jt-1 2.4.6 → 2.4.8

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

@@ -181,18 +181,15 @@
 12. 最终输出必须以 `<REPORT>` 开始，以 `</REPORT>` 结束；
 
 13. **行号计算规范**：
-    > - **Diff 头信息格式**：`@@ -84,9 +84,11 @@`
-        >   - `-84,9`：旧文件从第 84 行开始，共 9 行
-        >   - `+84,11`：新文件从第 84 行开始，共 11 行
-    > - **行号计算**（绝对行号，非相对偏移）：
-        >   - 初始值 = `new_start`（从 diff 头解析）
-        >   - 空格开头（上下文）：当前行号 = 计数器值，计数器 +1
-        >   - `-` 开头（删除）：跳过，计数器不变
-        >   - `+` 开头（新增）：当前行号 = 计数器值，计数器 +1
-    > - **示例**：`@@ -0,0 +1,49 @@`（新增文件）
-        >   - 第 1 行 `+`：行号 = 1
-        >   - 第 2 行 `+`：行号 = 2
-    > - **关键**：问题行号必须准确指向变更后代码的实际行号（绝对行号）
+    > - **行号定义**：行号是变更后文件中的**绝对行号**（从 1 开始计数）
+    > - **如何确定行号**：
+        >   - 读取变更后文件（基于 `New Path`）
+        >   - 找到新增代码在文件中的实际行号
+        >   - 例如：如果新增代码在变更后文件的第 43 行，则 `new_line = 43`
+    > - **示例**：
+        >   - 新增文件 `@@ -0,0 +1,49 @@`：第 1 行 `+` 的行号 = 1，第 2 行 `+` 的行号 = 2
+        >   - 已有文件 `@@ -42,3 +43,5 @@`：新增代码在文件第 43 行，则 `new_line = 43`
+    > - **关键**：问题行号必须准确指向变更后代码在文件中的实际行号（绝对行号）
 
 14. `<REPORT>` 标签示例中的问题块数量仅用于展示格式，实际数量由 review 结果决定；
 

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

@@ -9,19 +9,14 @@ description: 代码审查技能，审查变更代码并输出 REPORT 和 LINE_IN
 
 2. **解析文件信息**：从 `=== File Information ===` 部分提取
    - `Block Index`: 当前块索引号
-   - `New Start`: 当前 diff 块在变更后文件中的起始行号（**关键：用于计算绝对行号**）
+   - `New Start`: 当前 diff 块在变更后文件中的起始行号（仅供参考）
    - `New Count`: 当前 diff 块的行数
    - `New Path` / `Old Path`: 文件路径（去掉 `a/` 或 `b/` 前缀）
 
-3. **解析行号**：使用 `New Start` 作为基准，遍历 diff 内容计算每行的绝对行号
-   - 行号计算规则：
-     - **基准行号** = `New Start`（从 File Information 中获取）
-     - 遍历 diff 内容，只计数 `+` 开头（新增）和空格开头（上下文）的行
-     - 第 1 行 `+` 或空格：行号 = `New Start`
-     - 第 2 行 `+` 或空格：行号 = `New Start + 1`
-     - 以此类推，`-` 开头的删除行不计入行号
-   - **重要**：行号是变更后文件中的绝对行号，必须使用 `New Start` 作为基准计算
-   - **只报告当前 diff 块内的问题**：问题的行号必须在 `[New Start, New Start + New Count - 1]` 范围内
+3. **解析行号**：返回文件中变更代码的**绝对行号**（即变更后文件中的行号）
+   - 行号定义：行号是变更后文件中的绝对行号（从 1 开始计数）
+   - 例如：如果新增代码在变更后文件的第 43 行，则 `new_line = 43`
+   - **如何确定行号**：读取变更后文件（基于 `New Path`），找到新增代码在文件中的实际行号
 
 4. **读取上下文**：基于 New Path 读取变更后文件，涉及方法调用时追踪读取实现代码
 
@@ -58,5 +53,5 @@ description: 代码审查技能，审查变更代码并输出 REPORT 和 LINE_IN
 - 无问题时省略 `### 🔴 严重问题` 标题，但 `<LINE_INFO>` 必须输出（空数组：`[]`）
 - 每个问题以 `**问题 N**：` 开头，方便切分
 - **`<LINE_INFO>` 数组中的元素顺序必须与问题顺序一致**：第 1 个元素对应问题 1 的行号，第 2 个元素对应问题 2 的行号，以此类推
-- 行号计算：使用 `New Start` 作为基准，第 1 行 `+` 或空格的行号 = `New Start`，第 2 行 = `New Start + 1`，依此类推
+- 行号：返回变更后文件中的绝对行号（从 1 开始计数），例如文件第 43 行则 `new_line = 43`
 - **无严重问题时，LINE_INFO 必须输出空数组 `[]`**

package/docs/GITLAB_CR_NODE_TECHNICAL_DOCS.md

@@ -1,7 +1,7 @@
 # GitLab Code Review AI Tool 技术文档
 
 **项目名称**: job51-gitlab-cr-node  
-**当前版本**: 2.4.1  
+**当前版本**: 2.4.7  
 **作者**: tao.jing  
 **最后更新**: 2026-04-15  
 **项目地址**: https://gitdev.51job.com/51jobweb/ai-agent  
@@ -338,7 +338,7 @@ class GitLabAPIClient {
 
 ## 4. 关键算法与流程
 
-### 4.1 严重问题判断逻辑（核心）
+### 4.1 严重问题判断逻辑（核心）（2.4.4 更新）
 
 **位置**: `index.js:55-133`
 
@@ -368,9 +368,9 @@ class GitLabAPIClient {
 │  │ const hasSeriousProblem =                             │ │
 │  │     claudeResult.includes('严重问题')                   │ │
 │  │                                                        │ │
-│  │ 如果 false → 无严重问题                                │ │
-│  │   返回：{ reportContent: claudeResult,                 │ │
-│  │           lineInfo: lineInfoContent }                  │ │
+│  │ 如果 false → 无严重问题，返回标准空格式                 │ │
+│  │   reportContent: '<REPORT>\n## 🤖 AI 代码审查结果\n\n</REPORT>'│ │
+│  │   lineInfo: '[]'                                       │ │
 │  └───────────────────────────────────────────────────────┘ │
 │                          ↓ (有严重问题)                     │
 │  步骤 4: 检查标题是否符合要求                               │
@@ -390,7 +390,7 @@ class GitLabAPIClient {
 | 判断步骤 | 检查内容 | 判断条件 | 通过时动作 | 失败时动作 |
 |----------|----------|----------|------------|------------|
 | **步骤 1** | LINE_INFO 标签存在性 | `hasLineInfoTag && hasNonEmptyLineInfo` | 进入步骤 2 | 返回空格式 |
-| **步骤 2** | 严重问题关键词 | `claudeResult.includes('严重问题')` | 进入步骤 3 | 返回原报告 |
+| **步骤 2** | 严重问题关键词 | `claudeResult.includes('严重问题')` | 进入步骤 3 | 返回空格式 |
 | **步骤 3** | 标题格式正确性 | `claudeResult.includes('🤖 AI 代码审查结果')` | 接受结果 | 重试 (最多 5 次) |
 
 **重试策略详情**:
@@ -413,6 +413,10 @@ if (attempts >= maxAttempts) {
 [DEBUG] ... 【决策】报告包含严重问题且标题正确，接受结果 (尝试 1)
 ```
 
+**v2.4.4 变更**：
+- 无严重问题时统一返回标准空格式（之前返回原始结果）
+- 达到最大重试次数时返回最后一次 AI 结果（之前返回空格式）
+
 ### 4.2 评论发布决策逻辑
 
 **位置**: `index.js:173-183`
@@ -491,11 +495,11 @@ getDiffBlocks(diffObj) {
 | 空格 | `current_line++` | 上下文代码，计入行号 |
 | `-` | 不变 | 删除代码，不计入行号 |
 
-### 4.4 评论发布核心逻辑（详细）
+### 4.4 评论发布核心逻辑（详细）（2.4.6/2.4.7 更新）
 
-**位置**: `index.js:497-589`
+**位置**: `index.js:577-665`
 
-**完整发布流程**:
+**完整发布流程**（v2.4.6 更新）:
 ```
 ┌─────────────────────────────────────────────────────────────────────────┐
 │                        评论发布完整流程                                  │
@@ -509,54 +513,75 @@ getDiffBlocks(diffObj) {
 │  │ - start_sha: 起始提交 SHA                                          │ │
 │  └───────────────────────────────────────────────────────────────────┘ │
 │                                ↓                                        │
-│  步骤 2: 确定目标行号 (targetLine)                                       │
+│  步骤 2: 解析 LINE_INFO 中的所有问题行号                                  │
 │  ┌───────────────────────────────────────────────────────────────────┐ │
-│  │ 优先级 1: LINE_INFO 标签解析的行号 (最精确)                          │ │
-│  │ 优先级 2: diff 块起始行号 (后备方案)                                 │ │
+│  │ allLineInfo = parseAllLineInfoFromReviewResult(lineInfoTag)       │ │
 │  │                                                                    │ │
-│  │ 验证：parsedLineInfo.new_line 必须在 [new_start, new_end] 范围内   │ │
+│  │ v2.4.6 新增：支持多个问题行号                                       │ │
 │  └───────────────────────────────────────────────────────────────────┘ │
 │                                ↓                                        │
-│  步骤 3: 选择评论类型                                                   │
+│  步骤 3: 循环处理每个问题                                               │
 │  ┌───────────────────────────────────────────────────────────────────┐ │
-│  │ 有 targetLine → Diff 评论 (行级评论，定位到具体代码行)                │ │
-│  │ 无 targetLine → 一般讨论 (文件级评论)                               │ │
+│  │ for (let i = 0; i < allLineInfo.length; i++)                      │ │
+│  │   a. 提取单个问题报告内容                                          │ │
+│  │      singleProblemContent = extractSingleProblemReport(i + 1)     │ │
+│  │   b. 构建目标行号                                                  │ │
+│  │      - 删除代码：使用 old_line + old_path                         │ │
+│  │      - 新增/上下文：使用 new_line + new_path                      │ │
+│  │   c. 发布评论到对应行                                              │ │
+│  │   d. GitLab API 失败降级为一般讨论                                  │ │
 │  └───────────────────────────────────────────────────────────────────┘ │
 │                                ↓                                        │
-│  步骤 4: 调用 GitLab API 发布评论                                         │
-│  ┌───────────────────────────────────────────────────────────────────┐ │
-│  │ Diff 评论失败 → 自动降级为一般讨论                                  │ │
-│  └───────────────────────────────────────────────────────────────────┘ │
+│  步骤 4: 所有评论发布完成                                               │
 └─────────────────────────────────────────────────────────────────────────┘
 ```
 
-**targetLine 确定逻辑**:
+**targetLine 确定逻辑**（v2.4.7 更新）:
 ```javascript
-// 第一层：根据 diff 块第一行字符类型确定基础 targetLine
-let targetLine = lineInfo.firstLineFirstChar === '+'
-  ? { new_line: lineInfo.new_start, new_path: diff_info.new_path }
-  : lineInfo.firstLineFirstChar === '-'
-    ? { old_line: lineInfo.old_start, old_path: diff_info.old_path }
-    : { new_line: lineInfo.new_start, new_path: diff_info.new_path };
-
-// 第二层：尝试从 LINE_INFO 标签解析更精确的行号
-const parsedLineInfo = this.parseLineInfoFromReviewResult(lineInfoTag);
-if (parsedLineInfo) {
-  // 验证行号是否在 diff 块范围内
-  const newStart = lineInfo.new_start;
-  const newCount = lineInfo.new_count || 0;
-  const newEnd = newStart + newCount - 1;
+// v2.4.7：直接使用 AI 返回的绝对行号，不再验证范围
+for (let i = 0; i < allLineInfo.length; i++) {
+  const problemInfo = allLineInfo[i];
+  
+  let targetLine;
+  if (problemInfo.old_line && !problemInfo.new_line) {
+    // 删除代码，使用 old_line
+    targetLine = {
+      old_path: problemInfo.old_path,
+      old_line: problemInfo.old_line
+    };
+  } else if (problemInfo.new_line) {
+    // AI 返回的是文件中的绝对行号，直接使用
+    targetLine = {
+      new_path: problemInfo.new_path,
+      new_line: problemInfo.new_line
+    };
+  }
   
-  if (parsedLineInfo.new_line >= newStart && parsedLineInfo.new_line <= newEnd) {
-    // 行号有效，使用解析结果
-    targetLine = parsedLineInfo;
-  } else {
-    // 行号越界，使用 diff 块起始行号
-    debugLog(`解析的行号 ${parsedLineInfo.new_line} 不在 diff 块范围 [${newStart}, ${newEnd}] 内`);
+  if (!targetLine) {
+    // 无法解析行号，使用一般讨论
+    await this.createGeneralDiscussion(...);
+    continue;
   }
+  
+  // 发布评论到对应行
+  const payload = {
+    body: singleProblemContent,
+    position: {
+      position_type: 'text',
+      base_sha: baseSha,
+      head_sha: headSha,
+      start_sha: startSha,
+      ...targetLine
+    }
+  };
 }
 ```
 
+**v2.4.7 重要变更**：
+- **移除行号范围验证**：之前会验证 `parsedLineInfo.new_line ∈ [new_start, new_end]`
+- **直接使用绝对行号**：AI 返回的行号是文件中的绝对行号，直接使用
+- **原因**：AI 读取完整源文件后定位问题，返回的是文件实际行号，不是基于 `New Start` 计算的
+
 **GitLab API Payload 结构**:
 ```javascript
 // Diff 评论 Payload
@@ -626,38 +651,52 @@ async processWithThreadPool(tasks, processor, maxConcurrency = 3) {
 export GITLAB_CR_CONCURRENCY=5  # 默认 3
 ```
 
-### 4.6 行号解析算法
+### 4.6 行号解析算法（2.4.7 更新）
+
+**行号定义**：
+- 行号是变更后文件中的**绝对行号**（从 1 开始计数）
+- 例如：如果新增代码在变更后文件的第 43 行，则 `new_line = 43`
 
-**位置**: `index.js:435-470`
+**重要变更**（v2.4.7）：
+- **v2.4.7 之前**：使用 diff 块的 `New Start` 作为基准计算行号，并验证行号是否在 diff 块范围内
+- **v2.4.7 及之后**：AI 直接返回文件中的绝对行号，不再基于 `New Start` 计算，移除范围验证
 
-**LINE_INFO 解析函数**:
+**原因**：
+- AI 会读取完整的变更后文件来分析上下文
+- AI 在完整源文件中定位问题，返回的是文件中的绝对行号
+- 使用 `New Start` 验证行号范围会导致误判（如 diff 块 `New Start=1` 但 AI 返回行号 43）
+
+**原解析函数**：
 ```javascript
 parseLineInfoFromReviewResult(lineInfoTag) {
-  // 1. 从标签中提取 JSON 内容
+  // 从标签中提取 JSON 内容
   const jsonContent = lineInfoTag
     .replace(/<LINE_INFO>\s*/g, '')
     .replace(/\s*<\/LINE_INFO>/g, '')
     .trim();
   
-  // 2. 空数组处理 → 使用后备方案
   if (jsonContent === '[]') {
-    debugLog('LINE_INFO 为空数组，使用 diff 块起始行号作为后备方案');
-    return null;
+    return null; // 空数组使用后备方案
   }
   
-  // 3. 解析 JSON 数组
   const lineInfoArray = JSON.parse(jsonContent);
+  // 返回第一个问题的行号信息
+  return lineInfoArray[0];
+}
+```
+
+**新增解析函数**（v2.4.6）：
+```javascript
+parseAllLineInfoFromReviewResult(lineInfoTag) {
+  // 解析 LINE_INFO 中的所有问题行号
+  const jsonContent = lineInfoTag
+    .replace(/<LINE_INFO>\s*/g, '')
+    .replace(/\s*<\/LINE_INFO>/g, '')
+    .trim();
   
-  // 4. 返回第一个问题的行号信息
-  if (Array.isArray(lineInfoArray) && lineInfoArray.length > 0) {
-    const lineInfo = lineInfoArray[0];
-    return {
-      new_path: lineInfo.new_path,
-      new_line: lineInfo.new_line
-    };
-  }
+  if (jsonContent === '[]') return [];
   
-  return null; // 解析失败，使用后备方案
+  return JSON.parse(jsonContent);
 }
 ```
 
@@ -669,27 +708,7 @@ parseLineInfoFromReviewResult(lineInfoTag) {
 | 删除代码 (`-`) | 使用 `old_line` + `old_path` |
 | 上下文代码 | 使用 `new_line` + `new_path` |
 
-**行号验证逻辑**:
-```
-┌─────────────────────────────────────────────────────────────┐
-│                    行号验证流程                              │
-├─────────────────────────────────────────────────────────────┤
-│                                                             │
-│  1. 从 LINE_INFO 解析行号 → parsedLineInfo.new_line          │
-│                          ↓                                  │
-│  2. 计算 diff 块范围                                         │
-│     new_start = line_info.new_start                         │
-│     new_end = new_start + new_count - 1                     │
-│                          ↓                                  │
-│  3. 验证：parsedLineInfo.new_line ∈ [new_start, new_end]    │
-│                          ↓                                  │
-│  4. 判断：                                                   │
-│     - 在范围内 → 使用解析行号 (精确)                         │
-│     - 越界 → 使用 diff 块起始行号 (后备)                       │
-└─────────────────────────────────────────────────────────────┘
-```
-
-### 4.7 评论发布策略
+### 4.7 评论发布策略（2.4.6 更新）
 
 **增量发布模式** (`index.js:174-183`):
 ```javascript
@@ -701,14 +720,64 @@ if (review_result.includes('严重问题')) {
 }
 ```
 
-**行级评论定位** (`index.js:529-552`):
+**多问题评论发布**（v2.4.6 新增）：
 ```javascript
-// 优先使用 LINE_INFO 解析的行号
-const parsedLineInfo = this.parseLineInfoFromReviewResult(lineInfoTag);
-if (parsedLineInfo.new_line 在 diff 块范围内) {
-  targetLine = parsedLineInfo;
-} else {
-  targetLine = diff_block_start_line; // 后备方案
+// 一个 diff 块有多个问题时，为每个问题发布单独的评论
+for (let i = 0; i < allLineInfo.length; i++) {
+  const problemInfo = allLineInfo[i];
+  // 提取单个问题的报告内容
+  const singleProblemContent = this.extractSingleProblemReport(fullReportContent, i + 1);
+  
+  // 构建目标行号
+  let targetLine;
+  if (problemInfo.old_line && !problemInfo.new_line) {
+    targetLine = { old_path: problemInfo.old_path, old_line: problemInfo.old_line };
+  } else if (problemInfo.new_line) {
+    // AI 返回的是文件中的绝对行号，直接使用
+    targetLine = { new_path: problemInfo.new_path, new_line: problemInfo.new_line };
+  }
+  
+  // 发布评论到对应行
+  await this.createDiffDiscussion(projectId, mergeRequestIid, {
+    body: singleProblemContent,
+    position: { ...targetLine, ...shaInfo }
+  });
+}
+```
+
+**行级评论定位**（v2.4.7 更新）：
+```javascript
+// v2.4.7：直接使用 AI 返回的绝对行号，不再验证范围
+if (problemInfo.new_line) {
+  // AI 返回的是文件中的绝对行号，直接使用
+  targetLine = {
+    new_path: problemInfo.new_path,
+    new_line: problemInfo.new_line
+  };
+}
+```
+
+**报告切分方法**（v2.4.6 新增）：
+```javascript
+extractSingleProblemReport(fullReport, problemIndex) {
+  // 使用 **问题 N**：模式来切分问题
+  const problemBlocks = [];
+  let currentBlock = [];
+  
+  for (const line of lines) {
+    const problemMatch = line.match(/\*\*问题\s*(\d+)\*\*/);
+    if (problemMatch) {
+      if (currentBlock.length > 0) {
+        problemBlocks.push(currentBlock.join('\n'));
+        currentBlock = [];
+      }
+      currentBlock.push(line);
+    } else {
+      currentBlock.push(line);
+    }
+  }
+  
+  return problemBlocks[problemIndex - 1];
 }
 ```
 
@@ -1323,11 +1392,12 @@ npm run dev
 
 | 版本 | 日期 | 变更说明 |
 |------|------|----------|
-| 2.4.1 | 2026-04-08 | 修复 AI 审查结果为空时的返回值 |
-### 12.3 版本历史
-
-| 版本 | 日期 | 变更说明 |
-|------|------|----------|
+| 2.4.7 | 2026-04-15 | **行号计算逻辑重大修正**：修正 AI 行号计算方式，从使用 `New Start` 基准计算改为返回文件绝对行号；移除基于 diff 块范围的行号验证逻辑；更新 `code-review-rules.md` 和 `SKILL.md` 中的行号计算规范说明 |
+| 2.4.6 | 2026-04-15 | **多问题评论发布支持**：新增 `parseAllLineInfoFromReviewResult` 方法解析所有问题行号；新增 `extractSingleProblemReport` 方法切分单个问题报告；重构 `postSingleCommentToGitLab` 方法支持循环发布多条评论，每条评论定位到对应问题的行号 |
+| 2.4.5 | 2026-04-15 | **报告模板格式优化**：更新 `SKILL.md` 输出模板，使用 `**问题 N**：` 格式替代带圈数字序号；移除问题间的 `---` 分隔符，简化报告切分逻辑 |
+| 2.4.4 | 2026-04-15 | **标题验证逻辑修复**：修复 AI 审查结果标题验证逻辑，当有严重问题但标题不符合要求时重试，达到最大重试次数后返回最后一次结果 |
+| 2.4.3 | 2026-04-15 | **调试日志增强**：在 `getDiffBlocks` 方法中添加 diff 块解析日志，记录 `new_start` 和 `new_count` 值；添加文件拆分块数日志 |
+| 2.4.2 | 2026-04-15 | **元数据增强**：在临时 diff 文件中添加 `New Start` 和 `New Count` 元数据，供 AI 参考计算行号 |
 | 2.4.1 | 2026-04-08 | 修复 AI 审查结果为空时的返回值 |
 | 2.4.0 | 2026-03-25 | 更新 MR 审查模板 |
 | 2.3.8 | 2026-03-25 | 优化 AI 审核结果处理逻辑 |

package/index.js

@@ -383,7 +383,7 @@ ${diffObject.diff}`;
     const regex = /(?=@@\s-\d+(?:,\d+)?\s\+\d+(?:,\d+)?\s@@)/g;
     const diffBlocks = diffObj.diff.split(regex);
     // 过滤掉空块并提取行号信息
-    return diffBlocks
+    const result = diffBlocks
       .filter(block => block.trim() !== '')
       .map(block => {
         // 解析diff头信息 @@ -old_start,old_count +new_start,new_count @@
@@ -407,6 +407,8 @@ ${diffObject.diff}`;
           new_count = headerMatch[4] ? parseInt(headerMatch[4], 10) : 1;
         }
 
+        debugLog(`解析 diff 块：file=${diffObj.new_path || diffObj.old_path}, headerMatch=${headerMatch ? headerMatch[0] : 'N/A'}, new_start=${new_start}, new_count=${new_count}`);
+
         return {
           diff: block,
           new_path: diffObj.new_path,
@@ -427,6 +429,9 @@ ${diffObject.diff}`;
           }
         };
       });
+
+    debugLog(`文件 ${diffObj.new_path || diffObj.old_path} 拆分为 ${result.length} 个 diff 块`);
+    return result;
   }
 
   /**
@@ -591,11 +596,10 @@ ${diffObject.diff}`;
       const startSha = versionInfo.start_commit_sha;
       debugLog(`获取到版本信息 - base: ${baseSha}, head: ${headSha}, start: ${startSha}`);
 
-      // 解析 diff 头信息，计算有效行号范围
-      const newStart = diff_info.new_start || 1;
-      const newCount = diff_info.new_count || 1;
-      const maxValidLine = newStart + newCount - 1;
-      debugLog(`Diff 块行号范围：[${newStart}, ${maxValidLine}]，共 ${newCount} 行`);
+      // 解析 diff 头信息（用于日志记录）
+      const newStart = diff_info.line_info?.new_start || 1;
+      const newCount = diff_info.line_info?.new_count || 1;
+      debugLog(`Diff 块信息：new_start=${newStart}, new_count=${newCount}`);
 
       const allLineInfo = this.parseAllLineInfoFromReviewResult(lineInfoTag);
       debugLog(`解析到 ${allLineInfo.length} 个问题的行号信息`);
@@ -609,10 +613,8 @@ ${diffObject.diff}`;
         debugLog(`处理第 ${i + 1}/${allLineInfo.length} 个问题：文件=${problemInfo.new_path}, 行号=${problemInfo.new_line}`);
         const singleProblemContent = this.extractSingleProblemReport(fullReportContent, i + 1);
 
-        // 行号有效性验证和修正
+        // 构建目标行号
         let targetLine;
-        let originalLine = problemInfo.new_line;
-        let needsGeneralDiscussion = false;
 
         if (problemInfo.old_line && !problemInfo.new_line) {
           // 删除代码，使用 old_line
@@ -621,23 +623,18 @@ ${diffObject.diff}`;
             old_line: problemInfo.old_line
           };
         } else if (problemInfo.new_line) {
-          // 验证新行号是否在有效范围内
-          if (problemInfo.new_line < newStart || problemInfo.new_line > maxValidLine) {
-            debugLog(`⚠️ 行号 ${problemInfo.new_line} 超出有效范围 [${newStart}, ${maxValidLine}]，改用一般讨论`);
-            needsGeneralDiscussion = true;
-          } else {
-            targetLine = {
-              new_path: problemInfo.new_path,
-              new_line: problemInfo.new_line
-            };
-          }
+          // AI 返回的是文件中的绝对行号，直接使用
+          targetLine = {
+            new_path: problemInfo.new_path,
+            new_line: problemInfo.new_line
+          };
         }
 
-        if (needsGeneralDiscussion) {
-          // 行号无效，改用一般讨论
-          debugLog(`第 ${i + 1} 个问题的行号 ${originalLine} 无效，发布为一般讨论`);
+        if (!targetLine) {
+          // 无法解析行号，使用一般讨论
+          debugLog(`第 ${i + 1} 个问题无法解析行号，发布为一般讨论`);
           await this.createGeneralDiscussion(projectId, mergeRequestIid, file_path_with_line, singleProblemContent);
-          debugLog(`第 ${i + 1} 个问题的评论已发布 (作为一般讨论，行号无效)`);
+          debugLog(`第 ${i + 1} 个问题的评论已发布 (作为一般讨论)`);
           continue;
         }
 

package/package.json

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