gitlab-ai-review 4.2.4 → 6.3.9

package/index.js

@@ -3,12 +3,13 @@
  * 支持 CI/CD 自动配置和手动配置
  */
 
-import { getConfig, validateConfig, loadGuardConfig } from './lib/config.js';
+import { getConfig, validateConfig, loadGuardConfig, generateAIReviewGuardConfigFromGitLab, checkAndEnhanceReviewGuard } from './lib/config.js';
 import { GitLabClient } from './lib/gitlab-client.js';
 import { AIClient } from './lib/ai-client.js';
 import * as PromptTools from './lib/prompt-tools.js';
 import * as DiffParser from './lib/diff-parser.js';
-import * as ImpactAnalyzer from './lib/impact-analyzer.js';
+import * as ExportAnalyzer from './lib/export-analyzer.js';
+import { loadProjectDocuments, formatDocumentsInfo } from './lib/document-loader.js';
 
 /**
  * GitLab AI Review SDK 主类
@@ -53,6 +54,9 @@ export class GitLabAIReview {
         ...options.aiConfig,
       });
     }
+    
+    // 项目文档缓存
+    this.projectDocuments = null;
   }
 
   /**
@@ -63,26 +67,308 @@ export class GitLabAIReview {
   }
 
   /**
-   * 初始化并加载 Guard 配置（支持 AI 自动生成）
-   * 如果项目中没有 reviewguard.md，会自动分析项目并生成
+   * 初始化并加载 Guard 配置（支持 AI 自动生成和智能补充）
+   * 
+   * 工作流程：
+   * 1. 如果有现有的 reviewguard.md：
+   *    - enableEnhance=true: 结合项目代码检查是否完整，不完整则补充
+   *    - enableEnhance=false: 直接使用现有配置
+   * 2. 如果没有 reviewguard.md：
+   *    - useGitLabAPI=true: 通过 GitLab API 获取整个项目代码生成
+   *    - useGitLabAPI=false: 使用本地文件系统分析生成
+   * 
+   * @param {Object} options - 选项
+   * @param {boolean} options.useGitLabAPI - 是否使用 GitLab API 获取整个项目（默认 true）
+   * @param {boolean} options.enableEnhance - 是否启用智能补充模式（默认 true）
+   * @param {string} options.ref - 分支名（默认使用 MR 的目标分支）
    */
-  async initGuardConfig() {
+  async initGuardConfig(options = {}) {
+    const { useGitLabAPI = true, enableEnhance = true } = options;
+
     if (this.config.ai?.guardConfig) {
       return this.config.ai.guardConfig;
     }
 
-    const guardConfig = await loadGuardConfig(this.aiClient);
+    // 获取目标分支
+    let ref = options.ref || 'main';
+    try {
+      const mrInfo = await this.getMergeRequest();
+      ref = mrInfo.target_branch || ref;
+    } catch (e) {
+      // 使用默认分支
+    }
+
+    // 1. 先尝试从本地加载现有的 reviewguard.md
+    let guardConfig = await loadGuardConfig(null); // 不传 aiClient，只检查本地文件
     
     if (guardConfig) {
+      console.log(`📄 发现现有的 Guard 配置: ${guardConfig.filename}`);
+      
+      // 🎯 如果启用智能补充模式，检查并补充 reviewguard.md
+      if (enableEnhance && this.aiClient && useGitLabAPI && this.config.project.projectId) {
+        console.log('🔍 启用智能补充模式，检查 reviewguard.md 是否完整...');
+        
+        guardConfig = await checkAndEnhanceReviewGuard(
+          this.aiClient,
+          this.gitlabClient,
+          this.config.project.projectId,
+          ref,
+          guardConfig
+        );
+        
+        if (guardConfig.enhanced) {
+          console.log(`✅ Guard 配置已增强: ${guardConfig.filename}`);
+        } else if (guardConfig.isComplete) {
+          console.log(`✅ Guard 配置完整，无需补充: ${guardConfig.filename}`);
+        }
+      } else {
+        console.log(`✅ Guard 配置已加载: ${guardConfig.filename}`);
+      }
+      
       this.config.ai.guardConfig = guardConfig;
-      console.log(`✅ Guard 配置已加载: ${guardConfig.filename}${guardConfig.generated ? ' (AI自动生成)' : ''}`);
+      return guardConfig;
+    }
+
+    // 2. 本地没有找到，使用 AI 生成
+    console.log('📭 未找到现有的 reviewguard.md，将自动生成...');
+    
+    if (this.aiClient) {
+      if (useGitLabAPI && this.config.project.projectId) {
+        // 🎯 使用 GitLab API 获取整个项目来生成
+        console.log('📡 使用 GitLab API 模式获取整个项目...');
+        console.log(`   目标分支: ${ref}`);
+
+        guardConfig = await generateAIReviewGuardConfigFromGitLab(
+          this.aiClient,
+          this.gitlabClient,
+          this.config.project.projectId,
+          ref
+        );
+      } else {
+        // 使用本地模式（读取本地文件）
+        console.log('📂 使用本地模式分析项目...');
+        guardConfig = await loadGuardConfig(this.aiClient);
+      }
+    }
+    
+    if (guardConfig) {
+      this.config.ai.guardConfig = guardConfig;
+      console.log(`✅ Guard 配置已生成: ${guardConfig.filename}`);
     } else {
-      console.log('⚠️  未找到 Guard 配置，将使用默认审查规则');
+      console.log('⚠️  未能生成 Guard 配置，将使用默认审查规则');
     }
 
     return guardConfig;
   }
 
+  /**
+   * 加载项目文档（PRD.docx 和 TD.docx）
+   * 
+   * 从项目根目录的 documents 文件夹加载产品需求文档和技术设计文档，
+   * 使用 AI 生成总结，在后续代码审查时提供上下文。
+   * 
+   * @param {Object} options - 选项
+   * @param {string} options.documentsPath - documents 文件夹路径（默认 'documents'）
+   * @param {boolean} options.enableSummary - 是否使用 AI 生成文档总结（默认 true）
+   * @param {string} options.ref - 分支名（默认使用 MR 的目标分支）
+   * @returns {Promise<Object>} 文档对象 { prd, td, context }
+   */
+  async loadProjectDocuments(options = {}) {
+    const {
+      documentsPath = 'documents',
+      enableSummary = true,
+      ref: refOption,
+    } = options;
+
+    // 如果已经加载过，直接返回缓存
+    if (this.projectDocuments) {
+      console.log('📚 使用已缓存的项目文档');
+      return this.projectDocuments;
+    }
+
+    // 获取源分支（文档通常在 MR 的源分支上）
+    let ref = refOption || 'main';
+    try {
+      const mrInfo = await this.getMergeRequest();
+      ref = mrInfo.source_branch || ref;  // 改为从源分支读取
+    } catch (e) {
+      // 使用默认分支
+    }
+
+    // 加载文档
+    const documents = await loadProjectDocuments({
+      gitlabClient: this.gitlabClient,
+      projectId: this.config.project.projectId,
+      ref,
+      aiClient: enableSummary ? this.aiClient : null,
+      documentsPath,
+    });
+
+    // 缓存结果
+    this.projectDocuments = documents;
+
+    // 输出加载信息
+    if (documents.prd || documents.td) {
+      console.log('\n' + '='.repeat(80));
+      console.log('📚 项目文档加载详情');
+      console.log('='.repeat(80));
+      console.log(formatDocumentsInfo(documents));
+      console.log('='.repeat(80) + '\n');
+    }
+
+    return documents;
+  }
+
+  /**
+   * 获取项目文档的上下文字符串（用于审查）
+   * @returns {string} 文档上下文
+   */
+  getDocumentsContext() {
+    if (!this.projectDocuments || !this.projectDocuments.context) {
+      return '';
+    }
+    return this.projectDocuments.context;
+  }
+
+  /**
+   * 从 Package Registry 加载历史反馈样本
+   * 区分正样本（up > down）和负样本（down > up）
+   * 
+   * @param {Object} options - 选项
+   * @param {string} options.packageName - 包名（默认 'ai-review-data'）
+   * @param {string} options.packageVersion - 版本（默认 'latest'）
+   * @param {string} options.fileName - 文件名（默认 'review-history.json'）
+   * @param {number} options.maxSamples - 最大样本数（默认每种 5 个）
+   * @returns {Promise<Object>} { positive: [], negative: [] }
+   */
+  async loadFeedbackSamples(options = {}) {
+    const {
+      packageName = 'ai-review-feedback',
+      packageVersion = 'latest',
+      fileName = 'review-history.json',
+      maxSamples = 5
+    } = options;
+
+    const result = {
+      positive: [],  // 正样本（up > down）
+      negative: [],  // 负样本（down > up）
+      loaded: false
+    };
+
+    if (!this.config.project.projectId) {
+      console.log('⚠️  未配置项目 ID，跳过加载反馈样本');
+      return result;
+    }
+
+    console.log('\n📦 从 Package Registry 加载历史反馈样本...');
+
+    try {
+      // 1. 从 Package Registry 读取 review-history.json
+      const feedbackHistory = await this.gitlabClient.getPackageFile(
+        this.config.project.projectId,
+        packageName,
+        packageVersion,
+        fileName
+      );
+
+      if (!feedbackHistory || !Array.isArray(feedbackHistory) || feedbackHistory.length === 0) {
+        console.log('📭 没有历史反馈数据');
+        return result;
+      }
+
+      console.log(`📊 找到 ${feedbackHistory.length} 条历史反馈记录`);
+
+      // 2. 区分正负样本
+      const positiveFeedback = feedbackHistory.filter(f => f.up > f.down).slice(0, maxSamples * 2);
+      const negativeFeedback = feedbackHistory.filter(f => f.down > f.up).slice(0, maxSamples * 2);
+
+      console.log(`   - 正样本候选: ${positiveFeedback.length} 条`);
+      console.log(`   - 负样本候选: ${negativeFeedback.length} 条`);
+
+      // 3. 获取评论内容
+      for (const feedback of positiveFeedback) {
+        if (result.positive.length >= maxSamples) break;
+        
+        const note = await this.gitlabClient.getMergeRequestNote(
+          this.config.project.projectId,
+          feedback.mr,
+          feedback.note
+        );
+
+        if (note && note.body) {
+          result.positive.push({
+            mrIid: feedback.mr,
+            noteId: feedback.note,
+            content: note.body,
+            up: feedback.up,
+            down: feedback.down
+          });
+        }
+      }
+
+      for (const feedback of negativeFeedback) {
+        if (result.negative.length >= maxSamples) break;
+
+        const note = await this.gitlabClient.getMergeRequestNote(
+          this.config.project.projectId,
+          feedback.mr,
+          feedback.note
+        );
+
+        if (note && note.body) {
+          result.negative.push({
+            mrIid: feedback.mr,
+            noteId: feedback.note,
+            content: note.body,
+            up: feedback.up,
+            down: feedback.down
+          });
+        }
+      }
+
+      result.loaded = true;
+      console.log(`\n✅ 成功加载样本: 正样本 ${result.positive.length} 条, 负样本 ${result.negative.length} 条`);
+
+      // 输出正样本详情
+      if (result.positive.length > 0) {
+        console.log('\n' + '='.repeat(80));
+        console.log('📗 正样本详情（获得好评的审查意见）:');
+        console.log('='.repeat(80));
+        result.positive.forEach((sample, index) => {
+          console.log(`\n【正样本 ${index + 1}】MR !${sample.mrIid} | Note #${sample.noteId} | 👍${sample.up} 👎${sample.down}`);
+          console.log('-'.repeat(60));
+          // 截断过长的内容，只显示前 500 字符
+          const content = sample.content.length > 500 
+            ? sample.content.substring(0, 500) + '\n... (内容过长，已截断)'
+            : sample.content;
+          console.log(content);
+        });
+        console.log('\n' + '='.repeat(80));
+      }
+
+      // 输出负样本详情
+      if (result.negative.length > 0) {
+        console.log('\n' + '='.repeat(80));
+        console.log('📕 负样本详情（获得差评的审查意见）:');
+        console.log('='.repeat(80));
+        result.negative.forEach((sample, index) => {
+          console.log(`\n【负样本 ${index + 1}】MR !${sample.mrIid} | Note #${sample.noteId} | 👍${sample.up} 👎${sample.down}`);
+          console.log('-'.repeat(60));
+          const content = sample.content.length > 500 
+            ? sample.content.substring(0, 500) + '\n... (内容过长，已截断)'
+            : sample.content;
+          console.log(content);
+        });
+        console.log('\n' + '='.repeat(80));
+      }
+
+      return result;
+    } catch (error) {
+      console.warn(`⚠️  加载反馈样本失败: ${error.message}`);
+      return result;
+    }
+  }
+
   /**
    * 获取当前配置
    */
@@ -192,313 +478,271 @@ export class GitLabAIReview {
   }
 
   /**
-   * AI 审查 MR 的所有有意义的变更并自动添加行级评论（按文件批量处理）
-   * @param {Object} options - 选项
-   * @param {number} options.maxFiles - 最大审查文件数量（默认不限制）
-   * @returns {Promise<Array>} 评论结果数组
+   * 🎯 分析导出变更的影响（调用链分析）
+   * 1. 获取变更文件的新旧版本
+   * 2. 使用 TypeScript Compiler API 分析导出变更
+   * 3. 搜索其他文件对这些导出的引用
+   * @param {Array} changes - 变更列表
+   * @returns {Promise<Object>} 影响信息 Map
    */
-  async reviewAndCommentOnLines(options = {}) {
-    // 确保 Guard 配置已加载
-    await this.initGuardConfig();
-    
-    const { maxFiles = Infinity } = options;
-    const allChanges = await this.getMergeRequestChanges();
-    const changes = this.filterReviewableFiles(allChanges);
-    const results = [];
+  async analyzeExportImpact(changes) {
+    console.log('\n' + '='.repeat(80));
+    console.log('🔍 分析导出变更影响（调用链分析）...');
+    console.log('='.repeat(80));
 
-    const filesToReview = maxFiles === Infinity ? changes.length : Math.min(maxFiles, changes.length);
-    console.log(`共 ${changes.length} 个文件需要审查${maxFiles === Infinity ? '（不限制数量）' : `（最多审查 ${maxFiles} 个）`}（已过滤 ${allChanges.length - changes.length} 个文件）`);
+    const mrInfo = await this.getMergeRequest();
+    const sourceBranch = mrInfo.source_branch;
+    const targetBranch = mrInfo.target_branch;
+    const impactMap = {};
 
-    for (const change of changes.slice(0, filesToReview)) {
+    console.log(`\n📌 源分支: ${sourceBranch}`);
+    console.log(`📌 目标分支: ${targetBranch}\n`);
+
+    // 只分析支持的文件类型
+    const supportedExtensions = ['.js', '.ts', '.tsx', '.jsx', '.vue'];
+    const analyzableChanges = changes.filter(c => {
+      const path = c.new_path || c.old_path;
+      return supportedExtensions.some(ext => path.endsWith(ext));
+    });
+
+    console.log(`📂 共 ${analyzableChanges.length} 个文件可分析导出\n`);
+
+    for (const change of analyzableChanges) {
       const fileName = change.new_path || change.old_path;
+      const isNewFile = change.new_file;
+      const isDeletedFile = change.deleted_file;
+
+      console.log(`\n${'─'.repeat(60)}`);
+      console.log(`📄 分析文件: ${fileName}`);
       
       try {
-        console.log(`\n审查文件: ${fileName}`);
+        let oldExports = [];
+        let newExports = [];
+
+        // 获取旧版本内容（如果不是新文件）
+        if (!isNewFile && change.old_path) {
+          try {
+            console.log(`   📥 获取旧版本 (${targetBranch})...`);
+            const oldContent = await this.gitlabClient.getProjectFile(
+              this.config.project.projectId,
+              change.old_path,
+              targetBranch
+            );
+            if (oldContent) {
+              oldExports = ExportAnalyzer.extractExports(oldContent, change.old_path);
+              console.log(`   ✓ 旧版本导出: ${oldExports.length} 个 [${oldExports.map(e => e.name).join(', ')}]`);
+            }
+          } catch (e) {
+            console.log(`   ⚠️ 获取旧版本失败: ${e.message}`);
+          }
+        }
+
+        // 获取新版本内容（如果不是删除文件）
+        if (!isDeletedFile && change.new_path) {
+          try {
+            console.log(`   📥 获取新版本 (${sourceBranch})...`);
+            const newContent = await this.gitlabClient.getProjectFile(
+              this.config.project.projectId,
+              change.new_path,
+              sourceBranch
+            );
+            if (newContent) {
+              newExports = ExportAnalyzer.extractExports(newContent, change.new_path);
+              console.log(`   ✓ 新版本导出: ${newExports.length} 个 [${newExports.map(e => e.name).join(', ')}]`);
+            }
+          } catch (e) {
+            console.log(`   ⚠️ 获取新版本失败: ${e.message}`);
+          }
+        }
+
+        // 对比找出变更的导出
+        const changedExports = ExportAnalyzer.findChangedExports(oldExports, newExports);
         
-        // 解析 diff，提取有意义的变更
-        const hunks = DiffParser.parseDiff(change.diff);
-        const meaningfulChanges = DiffParser.extractMeaningfulChanges(hunks);
+        const totalChanges = changedExports.added.length + 
+                            changedExports.removed.length + 
+                            changedExports.modified.length;
 
-        if (meaningfulChanges.length === 0) {
-          console.log(`  跳过：没有有意义的变更`);
+        if (totalChanges === 0) {
+          console.log(`   ℹ️ 没有导出变更`);
           continue;
         }
 
-        console.log(`  发现 ${meaningfulChanges.length} 个有意义的变更`);
+        console.log(`\n   📊 导出变更统计:`);
+        if (changedExports.added.length > 0) {
+          console.log(`      🆕 新增: ${changedExports.added.map(e => e.name).join(', ')}`);
+        }
+        if (changedExports.removed.length > 0) {
+          console.log(`      🗑️ 删除: ${changedExports.removed.map(e => e.name).join(', ')}`);
+        }
+        if (changedExports.modified.length > 0) {
+          console.log(`      ✏️ 修改: ${changedExports.modified.map(e => 
+            `${e.name}(${e.changeType})`).join(', ')}`);
+        }
 
-        // 调用 AI 一次性审查整个文件的所有变更（按文件批量）
-        const fileReview = await this.reviewFileChanges(change, meaningfulChanges);
-        
-        // 智能合并修改块的评论
-        const mergedReviews = this.mergeModificationReviews(fileReview.reviews, meaningfulChanges);
-        
-        // 根据 AI 返回的结果，只对有问题的行添加评论
-        for (const review of mergedReviews) {
-          if (review.hasIssue) {
+        // 搜索受影响的文件（删除和修改的导出需要检查引用）
+        const symbolsToSearch = [
+          ...changedExports.removed,
+          ...changedExports.modified,
+        ];
+
+        const references = [];
+
+        if (symbolsToSearch.length > 0) {
+          console.log(`\n   🔎 搜索符号引用...`);
+          
+          for (const symbol of symbolsToSearch) {
             try {
-              // 构建评论位置参数 - 使用实际的变更行号
-              const positionParams = {
-                filePath: fileName,
-                oldPath: change.old_path,
-              };
-              
-              // 如果是修改块（同时有 oldLine 和 newLine），同时指定两个行号
-              if (review.oldLine && review.newLine) {
-                positionParams.oldLine = review.oldLine;
-                positionParams.newLine = review.newLine;
-              } else if (review.lineNumber) {
-                // 单独的删除或新增
-                const relatedChange = meaningfulChanges.find(c => c.lineNumber === review.lineNumber);
-                const isDeletion = relatedChange && relatedChange.type === 'deletion';
-                if (isDeletion) {
-                  positionParams.oldLine = review.lineNumber;
-                } else {
-                  positionParams.newLine = review.lineNumber;
-                }
-              }
-              
-              // 直接使用 AI 审查意见作为评论内容
-              const commentBody = `🤖 **AI 代码审查**\n\n${review.comment}`;
-              
-              const commentResult = await this.gitlabClient.createLineComment(
+              console.log(`      搜索: ${symbol.name}`);
+              const searchResults = await this.gitlabClient.searchInProject(
                 this.config.project.projectId,
-                this.config.project.mergeRequestIid,
-                commentBody,
-                positionParams
+                symbol.name,
+                sourceBranch
               );
 
-              results.push({
-                status: 'success',
-                fileName,
-                lineNumber: review.lineNumber || review.oldLine,
-                comment: review.comment,
-                commentResult,
-              });
+              // 过滤搜索结果
+              for (const result of searchResults) {
+                // 跳过当前文件
+                if (result.path === fileName) continue;
+                
+                const data = result.data || '';
+                
+                // 检查是否真的 import 了这个符号
+                const hasImport = data.includes(`import`) && data.includes(symbol.name);
+                const hasUsage = new RegExp(`\\b${symbol.name}\\b`).test(data);
+                
+                if (hasImport || hasUsage) {
+                  // 获取引用文件的完整内容以提取上下文
+                  let usageContext = data;
+                  try {
+                    const refFileContent = await this.gitlabClient.getProjectFile(
+                      this.config.project.projectId,
+                      result.path,
+                      sourceBranch
+                    );
+                    if (refFileContent) {
+                      usageContext = ExportAnalyzer.extractUsageContext(
+                        refFileContent, 
+                        symbol.name,
+                        2  // 上下文行数
+                      );
+                    }
+                  } catch (e) {
+                    // 使用搜索结果的数据
+                  }
 
-              const lineDesc = review.oldLine && review.newLine 
-                ? `第 ${review.oldLine}-${review.newLine} 行（修改块）` 
-                : `第 ${review.lineNumber} 行`;
-              console.log(`  ✓ ${lineDesc}：已添加评论`);
-            } catch (error) {
-              results.push({
-                status: 'error',
-                fileName,
-                lineNumber: review.lineNumber || review.oldLine,
-                error: error.message,
-              });
-              const lineDesc = review.oldLine && review.newLine 
-                ? `第 ${review.oldLine}-${review.newLine} 行` 
-                : `第 ${review.lineNumber} 行`;
-              console.log(`  ✗ ${lineDesc}：评论失败 - ${error.message}`);
+                  // 检查是否已添加这个文件
+                  const existing = references.find(r => r.file === result.path);
+                  if (existing) {
+                    if (!existing.symbols.includes(symbol.name)) {
+                      existing.symbols.push(symbol.name);
+                    }
+                  } else {
+                    references.push({
+                      file: result.path,
+                      symbols: [symbol.name],
+                      usageContext,
+                      startLine: result.startline || 1,
+                    });
+                  }
+                }
+              }
+            } catch (e) {
+              console.log(`      ⚠️ 搜索失败: ${e.message}`);
             }
-          } else {
-            const lineDesc = review.oldLine && review.newLine 
-              ? `第 ${review.oldLine}-${review.newLine} 行` 
-              : `第 ${review.lineNumber} 行`;
-            console.log(`  ✓ ${lineDesc}：代码质量良好`);
           }
         }
 
-        // 如果没有问题
-        if (fileReview.reviews.length === 0 || fileReview.reviews.every(r => !r.hasIssue)) {
-          console.log(`  ✓ 所有代码质量良好，无需评论`);
+        if (references.length > 0) {
+          console.log(`\n   ✅ 发现 ${references.length} 个文件引用了变更的导出:`);
+          references.forEach(ref => {
+            console.log(`      - ${ref.file} (使用: ${ref.symbols.join(', ')})`);
+          });
         }
 
+        // 存储影响信息
+        impactMap[fileName] = {
+          changedExports: {
+            added: changedExports.added.map(e => e.name),
+            removed: changedExports.removed.map(e => e.name),
+            modified: changedExports.modified.map(e => ({ 
+              name: e.name, 
+              changeType: e.changeType,
+              oldSignature: e.oldSignature,
+              newSignature: e.newSignature,
+            })),
+          },
+          references,
+        };
+
       } catch (error) {
-        results.push({
-          status: 'error',
-          fileName,
-          error: error.message,
-        });
-        console.log(`  ✗ 文件审查失败: ${error.message}`);
+        console.log(`   ❌ 分析失败: ${error.message}`);
       }
     }
 
-    return results;
-  }
-
-  /**
-   * 智能合并修改块的评论
-   * 如果相邻的删除和新增是同一个修改，合并为一个评论
-   * @param {Array} reviews - AI 返回的审查结果
-   * @param {Array} meaningfulChanges - 有意义的变更列表
-   * @returns {Array} 合并后的审查结果
-   */
-  mergeModificationReviews(reviews, meaningfulChanges) {
-    if (!reviews || reviews.length === 0) return reviews;
-    
-    const merged = [];
-    const processed = new Set();
-    
-    reviews.forEach((review, index) => {
-      if (processed.has(index)) return;
-      
-      const currentChange = meaningfulChanges.find(c => c.lineNumber === review.lineNumber);
-      if (!currentChange) {
-        merged.push(review);
-        return;
-      }
-      
-      // 如果是删除，查找是否有对应的新增（可能是修改）
-      if (currentChange.type === 'deletion') {
-        // 查找相近行号的新增
-        const nextReviewIndex = reviews.findIndex((r, i) => {
-          if (i <= index || processed.has(i)) return false;
-          const nextChange = meaningfulChanges.find(c => c.lineNumber === r.lineNumber);
-          // 相差不超过 5 行，且是新增类型
-          return nextChange && 
-                 nextChange.type === 'addition' && 
-                 Math.abs(nextChange.lineNumber - currentChange.lineNumber) <= 5;
-        });
-        
-        if (nextReviewIndex !== -1) {
-          const nextReview = reviews[nextReviewIndex];
-          const nextChange = meaningfulChanges.find(c => c.lineNumber === nextReview.lineNumber);
-          
-          // 合并为一个修改块的评论
-          merged.push({
-            hasIssue: review.hasIssue || nextReview.hasIssue,
-            oldLine: currentChange.lineNumber,  // 删除行
-            newLine: nextChange.lineNumber,     // 新增行
-            comment: review.hasIssue ? review.comment : nextReview.comment,  // 使用有问题的那个评论
-          });
-          
-          processed.add(index);
-          processed.add(nextReviewIndex);
-          return;
-        }
-      }
-      
-      // 如果不是修改块，保持原样
-      merged.push(review);
-      processed.add(index);
-    });
-    
-    return merged;
-  }
-
-  /**
-   * 审查单个文件的所有变更（一次 API 调用）
-   * @param {Object} change - 代码变更对象
-   * @param {Array} meaningfulChanges - 有意义的变更数组
-   * @returns {Promise<Object>} 审查结果 { reviews: [{lineNumber, hasIssue, comment}] }
-   */
-  async reviewFileChanges(change, meaningfulChanges) {
-    const aiClient = this.getAIClient();
-    const projectPrompt = this.config.ai?.guardConfig?.content || '';
-    const fileName = change.new_path || change.old_path;
-
-    // 构建整个文件的批量审查消息
-    const messages = PromptTools.buildFileReviewMessages(fileName, meaningfulChanges, projectPrompt);
-
-    // 🔍 输出完整的 Prompt（用于调试）
+    // 打印总结
     console.log('\n' + '='.repeat(80));
-    console.log('🔍 发送给 AI 的完整 Prompt:');
-    console.log('='.repeat(80));
-    messages.forEach((msg, index) => {
-      console.log(`\n📝 消息 ${index + 1} [${msg.role}]:`);
-      console.log('-'.repeat(80));
-      console.log(msg.content);
-    });
-    console.log('\n' + '='.repeat(80));
-    console.log('⏳ 等待 AI 响应...\n');
-
-    // 调用 AI（一次调用审查整个文件）
-    const response = await aiClient.sendMessage(messages);
-
-    // 🔍 输出 AI 的原始返回（用于调试）
-    console.log('\n' + '='.repeat(80));
-    console.log('📥 AI 原始返回:');
-    console.log('='.repeat(80));
-    console.log(response.content);
+    const filesWithChanges = Object.keys(impactMap).length;
+    const totalRefs = Object.values(impactMap).reduce(
+      (sum, info) => sum + info.references.length, 0
+    );
+    console.log(`✅ 调用链分析完成:`);
+    console.log(`   - ${filesWithChanges} 个文件有导出变更`);
+    console.log(`   - 共发现 ${totalRefs} 个文件受影响`);
     console.log('='.repeat(80) + '\n');
 
-    // 解析 AI 返回的 JSON
-    try {
-      // 提取 JSON（可能被包裹在 ```json ``` 中）
-      let jsonStr = response.content.trim();
-      const jsonMatch = jsonStr.match(/```json\s*([\s\S]*?)\s*```/);
-      if (jsonMatch) {
-        jsonStr = jsonMatch[1];
-      } else if (jsonStr.startsWith('```') && jsonStr.endsWith('```')) {
-        jsonStr = jsonStr.slice(3, -3).trim();
-      }
-
-      // 清理非 JSON 标准的值
-      jsonStr = jsonStr
-        .replace(/:\s*undefined/g, ': null')      // undefined → null
-        .replace(/:\s*NaN/g, ': null')            // NaN → null
-        .replace(/:\s*Infinity/g, ': null');      // Infinity → null
-
-      const result = JSON.parse(jsonStr);
-      
-      // 验证并过滤无效的 reviews
-      if (result.reviews && Array.isArray(result.reviews)) {
-        result.reviews = result.reviews.filter(review => {
-          // 过滤掉 lineNumber 无效的项
-          if (typeof review.lineNumber !== 'number' || isNaN(review.lineNumber)) {
-            console.warn(`  ⚠️  跳过无效的审查结果：lineNumber = ${review.lineNumber}`);
-            return false;
-          }
-          return true;
-        });
-      }
-      
-      return result;
-    } catch (error) {
-      console.error('解析 AI 返回的 JSON 失败:', error.message);
-      console.error('AI 原始返回:', response.content);
-      return { reviews: [] };
+    // 调试：输出完整的 impactMap
+    if (Object.keys(impactMap).length > 0) {
+      console.log('📋 影响分析详情:');
+      console.log(JSON.stringify(impactMap, null, 2));
+      console.log();
     }
+
+    return impactMap;
   }
 
   /**
-   * AI 审查 MR 的所有变更（包含影响分析）
+   * AI 审查 MR 的所有有意义的变更并自动添加行级评论（按文件批量处理）
    * @param {Object} options - 选项
    * @param {number} options.maxFiles - 最大审查文件数量（默认不限制）
-   * @param {number} options.maxAffectedFiles - 每个文件最多分析的受影响文件数量（默认 10）
-   * @param {boolean} options.enableImpactAnalysis - 是否启用影响分析（默认 true）
-   * @param {boolean} options.useCallChainAnalysis - 是否使用 TypeScript 调用链分析（默认 true）
+   * @param {boolean} options.loadFeedback - 是否加载历史反馈样本（默认 true）
    * @returns {Promise<Array>} 评论结果数组
    */
-  async reviewWithImpactAnalysis(options = {}) {
+  async reviewAndCommentOnLines(options = {}) {
     // 确保 Guard 配置已加载
     await this.initGuardConfig();
     
-    const { 
-      maxFiles = Infinity, 
-      maxAffectedFiles = 10,
-      enableImpactAnalysis = true,
-      useCallChainAnalysis = true 
-    } = options;
-    
+    const { maxFiles = Infinity, loadFeedback = true } = options;
     const allChanges = await this.getMergeRequestChanges();
     const changes = this.filterReviewableFiles(allChanges);
-    const mrInfo = await this.getMergeRequest();
-    const ref = mrInfo.target_branch || 'main';
     const results = [];
 
     const filesToReview = maxFiles === Infinity ? changes.length : Math.min(maxFiles, changes.length);
     console.log(`共 ${changes.length} 个文件需要审查${maxFiles === Infinity ? '（不限制数量）' : `（最多审查 ${maxFiles} 个）`}（已过滤 ${allChanges.length - changes.length} 个文件）`);
-    console.log(`影响分析: ${enableImpactAnalysis ? '已启用' : '已禁用'}`);
-    console.log(`调用链分析: ${useCallChainAnalysis ? '已启用（TypeScript）' : '已禁用（使用 GitLab Search）'}`);
-
-    // 🎯 新增：如果启用了调用链分析，先对所有变更进行一次性 TypeScript 分析
-    let callChainResult = null;
-    if (enableImpactAnalysis && useCallChainAnalysis) {
-      console.log('\n🔗 正在进行增量调用链分析（TypeScript Compiler API）...');
-      callChainResult = await ImpactAnalyzer.analyzeWithCallChain(changes.slice(0, filesToReview));
-      
-      if (callChainResult) {
-        console.log(`✅ 调用链分析完成：`);
-        console.log(`   - 分析文件数: ${callChainResult.filesAnalyzed}`);
-        console.log(`   - 构建调用链: ${callChainResult.callChains?.length || 0} 个`);
-        console.log(`   - 发现问题: ${callChainResult.codeContext?.totalIssues || 0} 个`);
-      } else {
-        console.log('ℹ️  调用链分析不可用，将降级使用 GitLab Search API');
+
+    // 🎯 第 0 阶段：加载历史反馈样本（正负样本学习）
+    let feedbackSamples = null;
+    if (loadFeedback) {
+      try {
+        feedbackSamples = await this.loadFeedbackSamples();
+      } catch (error) {
+        console.warn(`⚠️  加载反馈样本失败: ${error.message}`);
       }
     }
 
+    // 🎯 第一阶段：分析导出变更影响（调用链分析）
+    let impactMap = {};
+    try {
+      impactMap = await this.analyzeExportImpact(changes.slice(0, filesToReview));
+    } catch (error) {
+      console.error('❌ 调用链分析失败:', error.message);
+      console.log('⚠️  将继续进行审查，但不包含调用链信息\n');
+    }
+
+    // 🎯 第二阶段：逐文件审查
+    console.log('\n' + '='.repeat(80));
+    console.log('📝 开始逐文件代码审查');
+    console.log('='.repeat(80));
+
     for (const change of changes.slice(0, filesToReview)) {
       const fileName = change.new_path || change.old_path;
       
@@ -514,56 +758,46 @@ export class GitLabAIReview {
           continue;
         }
 
-        console.log(`  发现 ${meaningfulChanges.length} 个有意义的变更`);
-
-        // 影响分析（传入调用链结果）
-        let impactAnalysis = null;
-        if (enableImpactAnalysis) {
-          impactAnalysis = await ImpactAnalyzer.analyzeImpact({
-            gitlabClient: this.gitlabClient,
-            projectId: this.config.project.projectId,
-            ref: ref,
-            change: change,
-            maxAffectedFiles: maxAffectedFiles,
-            callChainResult: callChainResult,  // 🎯 传入调用链结果
-          });
+        console.log(`  发现 ${meaningfulChanges.length} 个变更块`);
+
+        // 获取该文件的调用链影响信息
+        const impactInfo = impactMap[fileName] || null;
+        if (impactInfo && impactInfo.references.length > 0) {
+          console.log(`  ✓ 已获取调用链信息: ${impactInfo.references.length} 个文件引用了变更的导出`);
         }
 
-        // 调用 AI 审查（包含影响分析）
-        const fileReview = await this.reviewFileChangesWithImpact(
-          change, 
-          meaningfulChanges, 
-          impactAnalysis
-        );
-        
-        // 智能合并修改块的评论
-        const mergedReviews = this.mergeModificationReviews(fileReview.reviews, meaningfulChanges);
+        // 调用 AI 一次性审查整个文件的所有变更（携带调用链信息和历史反馈样本）
+        const fileReview = await this.reviewFileChanges(change, meaningfulChanges, impactInfo, feedbackSamples);
         
-        // 根据 AI 返回的结果，只对有问题的行添加评论
-        for (const review of mergedReviews) {
+        // 根据 AI 返回的结果，直接使用 AI 提供的行号添加评论
+        for (const review of (fileReview.reviews || [])) {
           if (review.hasIssue) {
             try {
-              // 构建评论位置参数 - 使用实际的变更行号
+              // 验证 AI 返回的行号
+              if (typeof review.lineNumber !== 'number' || review.lineNumber <= 0) {
+                console.warn(`  ⚠️  无效的行号: ${review.lineNumber}`);
+                continue;
+              }
+
+              // 构建评论位置参数 - 直接使用 AI 返回的行号
               const positionParams = {
                 filePath: fileName,
                 oldPath: change.old_path,
               };
               
-              // 如果是修改块（同时有 oldLine 和 newLine），同时指定两个行号
-              if (review.oldLine && review.newLine) {
-                positionParams.oldLine = review.oldLine;
-                positionParams.newLine = review.newLine;
-              } else if (review.lineNumber) {
-                // 单独的删除或新增
-                const relatedChange = meaningfulChanges.find(c => c.lineNumber === review.lineNumber);
-                const isDeletion = relatedChange && relatedChange.type === 'deletion';
-                if (isDeletion) {
-                  positionParams.oldLine = review.lineNumber;
-                } else {
-                  positionParams.newLine = review.lineNumber;
-                }
+              // 根据 AI 返回的 isOldLine 决定使用哪种行号
+              if (review.isOldLine === true) {
+                // 删除类型：使用旧文件行号
+                positionParams.oldLine = review.lineNumber;
+              } else {
+                // 新增或修改类型：使用新文件行号
+                positionParams.newLine = review.lineNumber;
               }
               
+              // 打印行号信息用于调试
+              console.log(`  📍 AI 返回行号: ${review.lineNumber}, isOldLine: ${review.isOldLine || false}`);
+              console.log(`     使用参数: oldLine=${positionParams.oldLine || 'N/A'}, newLine=${positionParams.newLine || 'N/A'}`);
+              
               // 直接使用 AI 审查意见作为评论内容
               const commentBody = `🤖 **AI 代码审查**\n\n${review.comment}`;
               
@@ -577,15 +811,13 @@ export class GitLabAIReview {
               results.push({
                 status: 'success',
                 fileName,
-                lineNumber: review.lineNumber || review.newLine || review.oldLine,
+                lineNumber: review.lineNumber,
+                isOldLine: review.isOldLine || false,
                 comment: review.comment,
                 commentResult,
               });
 
-              const lineDesc = review.oldLine && review.newLine 
-                ? `第 ${review.oldLine}-${review.newLine} 行（修改块）` 
-                : `第 ${review.lineNumber} 行`;
-              console.log(`  ✓ ${lineDesc}：已添加评论`);
+              console.log(`  ✓ 第 ${review.lineNumber} 行：已添加评论`);
             } catch (error) {
               results.push({
                 status: 'error',
@@ -615,29 +847,96 @@ export class GitLabAIReview {
       }
     }
 
+    // 🎯 生成并发布 MR 总结评论
+    if (options.enableSummary !== false) {
+      try {
+        await this.generateAndPostSummary(results, changes.slice(0, filesToReview));
+      } catch (error) {
+        console.error('❌ 生成 MR 总结失败:', error.message);
+      }
+    }
+
     return results;
   }
 
   /**
-   * 审查单个文件的所有变更（包含影响分析）
+   * 处理 AI 返回的审查结果
+   * 验证 lineNumber 是否有效
+   * @param {Array} reviews - AI 返回的审查结果
+   * @param {Array} meaningfulChanges - 有意义的变更列表（用于参考）
+   * @returns {Array} 处理后的审查结果
+   */
+  mergeModificationReviews(reviews, meaningfulChanges) {
+    if (!reviews || reviews.length === 0) return reviews;
+    
+    // 验证 lineNumber 是否有效
+    return reviews.filter(review => {
+      if (typeof review.lineNumber !== 'number' || review.lineNumber <= 0) {
+        console.warn(`  ⚠️  跳过无效的审查结果：lineNumber = ${review.lineNumber}`);
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * 审查单个文件的所有变更（一次 API 调用）
    * @param {Object} change - 代码变更对象
    * @param {Array} meaningfulChanges - 有意义的变更数组
-   * @param {Object} impactAnalysis - 影响分析结果
+   * @param {Object} impactInfo - 调用链影响信息（可选）
+   * @param {Object} feedbackSamples - 历史反馈样本（可选）
    * @returns {Promise<Object>} 审查结果 { reviews: [{lineNumber, hasIssue, comment}] }
    */
-  async reviewFileChangesWithImpact(change, meaningfulChanges, impactAnalysis) {
+  async reviewFileChanges(change, meaningfulChanges, impactInfo = null, feedbackSamples = null) {
     const aiClient = this.getAIClient();
     const projectPrompt = this.config.ai?.guardConfig?.content || '';
     const fileName = change.new_path || change.old_path;
 
-    // 构建包含影响分析的批量审查消息
-    const messages = impactAnalysis 
-      ? PromptTools.buildFileReviewWithImpactMessages(fileName, meaningfulChanges, impactAnalysis, projectPrompt)
-      : PromptTools.buildFileReviewMessages(fileName, meaningfulChanges, projectPrompt);
+    // 🎯 获取完整文件内容
+    let fullFileContent = null;
+    try {
+      const mrInfo = await this.getMergeRequest();
+      const ref = mrInfo.target_branch || 'main';
+      
+      // 优先获取新文件内容，如果不存在则获取旧文件
+      if (change.new_path && !change.deleted_file) {
+        fullFileContent = await this.gitlabClient.getProjectFile(
+          this.config.project.projectId,
+          change.new_path,
+          ref
+        );
+      } else if (change.old_path) {
+        fullFileContent = await this.gitlabClient.getProjectFile(
+          this.config.project.projectId,
+          change.old_path,
+          ref
+        );
+      }
+      
+      if (fullFileContent) {
+        console.log(`  ✓ 已获取完整文件内容（${fullFileContent.split('\n').length} 行）`);
+      }
+    } catch (error) {
+      console.warn(`  ⚠️  获取完整文件内容失败: ${error.message}`);
+    }
+
+    // 📚 获取项目文档上下文
+    const documentsContext = this.getDocumentsContext();
+
+    // 构建整个文件的批量审查消息（包含完整文件内容、调用链信息、历史反馈样本和文档上下文）
+    const messages = PromptTools.buildFileReviewMessages(
+      fileName, 
+      meaningfulChanges, 
+      projectPrompt, 
+      fullFileContent, 
+      impactInfo, 
+      feedbackSamples,
+      documentsContext  // 新增文档上下文参数
+    );
 
     // 🔍 输出完整的 Prompt（用于调试）
     console.log('\n' + '='.repeat(80));
-    console.log('🔍 发送给 AI 的完整 Prompt (包含影响分析):');
+    console.log('🔍 发送给 AI 的完整 Prompt:');
     console.log('='.repeat(80));
     messages.forEach((msg, index) => {
       console.log(`\n📝 消息 ${index + 1} [${msg.role}]:`);
@@ -645,42 +944,76 @@ export class GitLabAIReview {
       console.log(msg.content);
     });
     console.log('\n' + '='.repeat(80));
-    console.log('⏳ 等待 AI 响应...\n');
+    console.log('⏳ AI 流式响应中...\n');
 
-    // 调用 AI（一次调用审查整个文件）
-    const response = await aiClient.sendMessage(messages);
-
-    // 🔍 输出 AI 的原始返回（用于调试）
-    console.log('\n' + '='.repeat(80));
-    console.log('📥 AI 原始返回 (包含影响分析):');
-    console.log('='.repeat(80));
-    console.log(response.content);
+    // 🎯 使用流式调用 AI（实时输出响应）
+    console.log('📥 AI 实时响应:');
+    console.log('-'.repeat(80));
+    
+    const response = await aiClient.sendMessageStream(messages, (chunk) => {
+      // 实时打印 AI 的响应内容
+      if (chunk.content) {
+        process.stdout.write(chunk.content);
+      }
+    });
+    
+    console.log('\n' + '-'.repeat(80));
+    console.log('✅ AI 响应完成');
     console.log('='.repeat(80) + '\n');
 
     // 解析 AI 返回的 JSON
     try {
       // 提取 JSON（可能被包裹在 ```json ``` 中）
       let jsonStr = response.content.trim();
+      
+      // 🔍 增强 JSON 提取逻辑
       const jsonMatch = jsonStr.match(/```json\s*([\s\S]*?)\s*```/);
       if (jsonMatch) {
         jsonStr = jsonMatch[1];
       } else if (jsonStr.startsWith('```') && jsonStr.endsWith('```')) {
         jsonStr = jsonStr.slice(3, -3).trim();
+      } else {
+        const bracketMatch = jsonStr.match(/\{[\s\S]*\}/);
+        if (bracketMatch) {
+          jsonStr = bracketMatch[0];
+        }
       }
 
-      // 清理非 JSON 标准的值
+      // 🧹 清理非 JSON 标准的值和尾部垃圾
       jsonStr = jsonStr
-        .replace(/:\s*undefined/g, ': null')      // undefined → null
-        .replace(/:\s*NaN/g, ': null')            // NaN → null
-        .replace(/:\s*Infinity/g, ': null');      // Infinity → null
+        .replace(/:\s*undefined/g, ': null')
+        .replace(/:\s*NaN/g, ': null')
+        .replace(/:\s*Infinity/g, ': null')
+        .replace(/,(\s*[}\]])/g, '$1')
+        .trim();
+      
+      // 🔍 检查 JSON 是否完整（基本的括号匹配）
+      const openBraces = (jsonStr.match(/\{/g) || []).length;
+      const closeBraces = (jsonStr.match(/\}/g) || []).length;
+      const openBrackets = (jsonStr.match(/\[/g) || []).length;
+      const closeBrackets = (jsonStr.match(/\]/g) || []).length;
+      
+      if (openBraces !== closeBraces || openBrackets !== closeBrackets) {
+        console.warn('⚠️  检测到不完整的 JSON（括号不匹配）');
+        console.warn(`   - 花括号: 开 ${openBraces}, 闭 ${closeBraces}`);
+        console.warn(`   - 方括号: 开 ${openBrackets}, 闭 ${closeBrackets}`);
+        
+        if (openBraces > closeBraces) {
+          jsonStr += '}'.repeat(openBraces - closeBraces);
+          console.warn(`   - 已自动添加 ${openBraces - closeBraces} 个闭花括号`);
+        }
+        if (openBrackets > closeBrackets) {
+          jsonStr += ']'.repeat(openBrackets - closeBrackets);
+          console.warn(`   - 已自动添加 ${openBrackets - closeBrackets} 个闭方括号`);
+        }
+      }
 
       const result = JSON.parse(jsonStr);
       
-      // 验证并过滤无效的 reviews
+      // 验证并过滤无效的 reviews（现在使用 lineNumber 而不是 blockIndex）
       if (result.reviews && Array.isArray(result.reviews)) {
         result.reviews = result.reviews.filter(review => {
-          // 过滤掉 lineNumber 无效的项
-          if (typeof review.lineNumber !== 'number' || isNaN(review.lineNumber)) {
+          if (typeof review.lineNumber !== 'number' || isNaN(review.lineNumber) || review.lineNumber <= 0) {
             console.warn(`  ⚠️  跳过无效的审查结果：lineNumber = ${review.lineNumber}`);
             return false;
           }
@@ -690,12 +1023,85 @@ export class GitLabAIReview {
       
       return result;
     } catch (error) {
-      console.error('解析 AI 返回的 JSON 失败:', error.message);
-      console.error('AI 原始返回:', response.content);
+      console.error('❌ 解析 AI 返回的 JSON 失败:', error.message);
+      const position = parseInt(error.message.match(/position (\d+)/)?.[1] || '0');
+      if (position > 0) {
+        const start = Math.max(0, position - 50);
+        const end = Math.min(response.content.length, position + 50);
+        console.error('\n出错位置附近的内容:');
+        console.error(response.content.substring(start, end));
+        console.error(' '.repeat(Math.min(50, position - start)) + '^^^');
+      }
+      console.error('\nAI 原始返回（前 2000 字符）:', response.content.substring(0, 2000));
       return { reviews: [] };
     }
   }
 
+  /**
+   * 生成并发布 MR 总结评论
+   * @param {Array} results - 审查结果数组
+   * @param {Array} changes - 代码变更数组
+   */
+  async generateAndPostSummary(results, changes) {
+    console.log('\n' + '='.repeat(80));
+    console.log('📝 正在生成 MR 总结评论...');
+    console.log('='.repeat(80));
+
+    const aiClient = this.getAIClient();
+    
+    // 统计信息
+    const stats = {
+      totalFiles: changes.length,
+      reviewedFiles: results.filter(r => r.status === 'success' || r.status === 'error').length,
+      successComments: results.filter(r => r.status === 'success').length,
+      failedComments: results.filter(r => r.status === 'error').length,
+      filesList: changes.map(c => c.new_path || c.old_path),
+    };
+
+    // 按文件分组评论
+    const commentsByFile = {};
+    results.forEach(result => {
+      if (result.status === 'success' && result.fileName) {
+        if (!commentsByFile[result.fileName]) {
+          commentsByFile[result.fileName] = [];
+        }
+        commentsByFile[result.fileName].push({
+          lineNumber: result.lineNumber,
+          isOldLine: result.isOldLine,
+          comment: result.comment,
+        });
+      }
+    });
+
+    // 构建总结 prompt
+    const summaryPrompt = PromptTools.buildMRSummaryPrompt(stats, commentsByFile);
+    const messages = [
+      { role: 'system', content: '你是一个专业的代码审查助手，负责总结 Merge Request 的审查结果。' },
+      { role: 'user', content: summaryPrompt },
+    ];
+
+    // 🎯 使用流式调用 AI 生成总结
+    console.log('📥 AI 生成总结中...');
+    console.log('-'.repeat(80));
+    
+    const response = await aiClient.sendMessageStream(messages, (chunk) => {
+      // 实时打印 AI 的响应内容
+      if (chunk.content) {
+        process.stdout.write(chunk.content);
+      }
+    });
+    
+    console.log('\n' + '-'.repeat(80));
+    const summary = response.content.trim();
+
+    // 发布总结评论
+    console.log('\n📤 发布 MR 总结评论...\n');
+    await this.addComment(summary);
+    
+    console.log('✅ MR 总结评论已发布');
+    console.log('='.repeat(80) + '\n');
+  }
+
   /**
    * 测试方法
    */
@@ -708,7 +1114,7 @@ export class GitLabAIReview {
 export { getConfig, validateConfig, loadGuardConfig } from './lib/config.js';
 export { GitLabClient } from './lib/gitlab-client.js';
 export { AIClient } from './lib/ai-client.js';
-export { PromptTools, DiffParser, ImpactAnalyzer };
+export { PromptTools, DiffParser };
 
 // 默认导出
 export default GitLabAIReview;