gitlab-ai-review 4.2.3 → 6.3.9

package/lib/diff-parser.js

@@ -1,5 +1,6 @@
 /**
  * Diff 解析工具 - 解析 Git Diff 格式
+ * 按块拆分：连续的删除+新增组合为一个变更块
  */
 
 /**
@@ -106,9 +107,23 @@ export function calculateNewLineNumber(hunk, changeIndex) {
 }
 
 /**
- * 提取有意义的变更（忽略纯空白变更）
+ * 判断内容是否有意义（非空白、非纯符号）
+ */
+function isContentMeaningful(content) {
+  if (!content) return false;
+  const trimmed = content.trim();
+  return trimmed.length > 0 && !/^[{}()\[\];,]*$/.test(trimmed);
+}
+
+/**
+ * 提取有意义的变更（按块拆分）
+ * 规则：
+ * 1. 连续的删除行 + 紧随其后的连续新增行 = 一个"修改块"
+ * 2. 只有删除行（后面是上下文或结束）= 一个"删除块"  
+ * 3. 只有新增行（前面是上下文或开始）= 一个"新增块"
+ * 
  * @param {Array} hunks - hunks 数组
- * @returns {Array} 有意义的变更数组
+ * @returns {Array} 有意义的变更块数组
  */
 export function extractMeaningfulChanges(hunks) {
   const meaningfulChanges = [];
@@ -117,57 +132,142 @@ export function extractMeaningfulChanges(hunks) {
     let currentNewLine = hunk.newStart;
     let currentOldLine = hunk.oldStart;
 
-    hunk.changes.forEach((change, index) => {
-      if (change.type === 'addition') {
-        const content = change.content.trim();
+    // 暂存当前正在收集的删除行和新增行
+    let pendingDeletions = [];
+    let pendingAdditions = [];
+    let deletionStartLine = null;
+    let additionStartLine = null;
+    let contextBefore = [];
+
+    // 完成当前变更块并添加到结果
+    const flushBlock = (contextAfter = []) => {
+      // 检查是否有有意义的内容
+      const hasMeaningfulDeletions = pendingDeletions.some(d => isContentMeaningful(d.content));
+      const hasMeaningfulAdditions = pendingAdditions.some(a => isContentMeaningful(a.content));
+
+      if (!hasMeaningfulDeletions && !hasMeaningfulAdditions) {
+        // 没有有意义的内容，跳过
+        pendingDeletions = [];
+        pendingAdditions = [];
+        deletionStartLine = null;
+        additionStartLine = null;
+        return;
+      }
+
+      // 创建变更块
+      const block = {
+        // 类型：同时有删除和新增是修改，只有删除是删除，只有新增是新增
+        type: (pendingDeletions.length > 0 && pendingAdditions.length > 0) ? 'modification' 
+             : (pendingDeletions.length > 0) ? 'deletion' 
+             : 'addition',
+        
+        // 删除部分
+        deletions: pendingDeletions.length > 0 ? {
+          startLine: deletionStartLine,
+          endLine: deletionStartLine + pendingDeletions.length - 1,
+          lines: pendingDeletions.map(d => d.content || ''),
+        } : null,
+        
+        // 新增部分
+        additions: pendingAdditions.length > 0 ? {
+          startLine: additionStartLine,
+          endLine: additionStartLine + pendingAdditions.length - 1,
+          lines: pendingAdditions.map(a => a.content || ''),
+        } : null,
+
+        // hunk 信息
+        hunk: hunk.header,
+        hunkRange: {
+          oldStart: hunk.oldStart,
+          oldEnd: hunk.oldStart + hunk.oldLines - 1,
+          newStart: hunk.newStart,
+          newEnd: hunk.newStart + hunk.newLines - 1,
+        },
         
-        // 过滤空行和仅包含符号的行
-        if (content.length > 0 && !/^[{}()\[\];,]*$/.test(content)) {
-          meaningfulChanges.push({
-            type: 'addition',
-            content: change.content,
-            lineNumber: currentNewLine,
-            hunk: hunk.header,
-            hunkRange: {  // 添加 hunk 的范围信息
-              oldStart: hunk.oldStart,
-              oldEnd: hunk.oldStart + hunk.oldLines - 1,
-              newStart: hunk.newStart,
-              newEnd: hunk.newStart + hunk.newLines - 1,
-            },
-            context: {
-              before: hunk.changes.slice(Math.max(0, index - 2), index).map(c => c.content),
-              after: hunk.changes.slice(index + 1, index + 3).map(c => c.content),
-            },
-          });
+        // 上下文
+        context: {
+          before: [...contextBefore],
+          after: contextAfter,
+        },
+      };
+
+      meaningfulChanges.push(block);
+
+      // 重置
+      pendingDeletions = [];
+      pendingAdditions = [];
+      deletionStartLine = null;
+      additionStartLine = null;
+    };
+
+    hunk.changes.forEach((change, index) => {
+      if (change.type === 'deletion') {
+        // 如果已经在收集新增行，说明删除和新增不连续，需要先 flush
+        if (pendingAdditions.length > 0) {
+          // 获取当前位置后面的上下文
+          const afterContext = hunk.changes.slice(index, index + 2)
+            .filter(c => c.type === 'context')
+            .map(c => c.content || '');
+          flushBlock(afterContext);
+          contextBefore = [];
         }
-        currentNewLine++;
-      } else if (change.type === 'deletion') {
-        const content = change.content.trim();
         
-        if (content.length > 0 && !/^[{}()\[\];,]*$/.test(content)) {
-          meaningfulChanges.push({
-            type: 'deletion',
-            content: change.content,
-            lineNumber: currentOldLine,  // 使用旧文件的行号
-            hunk: hunk.header,
-            hunkRange: {  // 添加 hunk 的范围信息
-              oldStart: hunk.oldStart,
-              oldEnd: hunk.oldStart + hunk.oldLines - 1,
-              newStart: hunk.newStart,
-              newEnd: hunk.newStart + hunk.newLines - 1,
-            },
-            context: {
-              before: hunk.changes.slice(Math.max(0, index - 2), index).map(c => c.content),
-              after: hunk.changes.slice(index + 1, index + 3).map(c => c.content),
-            },
-          });
+        // 记录删除起始行
+        if (deletionStartLine === null) {
+          deletionStartLine = currentOldLine;
+          // 收集之前的上下文
+          contextBefore = hunk.changes.slice(Math.max(0, index - 2), index)
+            .filter(c => c.type === 'context')
+            .map(c => c.content || '');
         }
+        
+        pendingDeletions.push({
+          lineNumber: currentOldLine,
+          content: change.content,
+        });
         currentOldLine++;
+
+      } else if (change.type === 'addition') {
+        // 记录新增起始行
+        if (additionStartLine === null) {
+          additionStartLine = currentNewLine;
+          // 如果没有待处理的删除，收集之前的上下文
+          if (pendingDeletions.length === 0) {
+            contextBefore = hunk.changes.slice(Math.max(0, index - 2), index)
+              .filter(c => c.type === 'context')
+              .map(c => c.content || '');
+          }
+        }
+        
+        pendingAdditions.push({
+          lineNumber: currentNewLine,
+          content: change.content,
+        });
+        currentNewLine++;
+
       } else if (change.type === 'context') {
+        // 遇到上下文行，完成当前块
+        if (pendingDeletions.length > 0 || pendingAdditions.length > 0) {
+          const afterContext = hunk.changes.slice(index, index + 2)
+            .filter(c => c.type === 'context')
+            .map(c => c.content || '');
+          flushBlock(afterContext);
+        }
+        
+        // 更新上下文
+        contextBefore = hunk.changes.slice(Math.max(0, index - 1), index + 1)
+          .filter(c => c.type === 'context')
+          .map(c => c.content || '');
+        
         currentNewLine++;
         currentOldLine++;
       }
     });
+
+    // 处理最后一个块
+    if (pendingDeletions.length > 0 || pendingAdditions.length > 0) {
+      flushBlock([]);
+    }
   });
 
   return meaningfulChanges;
@@ -209,4 +309,3 @@ export default {
   extractMeaningfulChanges,
   generateDiffSummary,
 };
-

package/lib/document-loader.js

@@ -0,0 +1,329 @@
+/**
+ * 文档加载器 - 加载并解析 documents 文件夹下的 PRD.docx 和 TD.docx
+ * 为 AI Review 提供产品和技术背景上下文
+ */
+
+import mammoth from 'mammoth';
+
+/**
+ * 文档类型枚举
+ */
+export const DocumentType = {
+  PRD: 'PRD', // Product Requirement Document 产品需求文档
+  TD: 'TD',   // Technical Document 技术文档
+};
+
+/**
+ * 从 base64 编码的 docx 内容中提取文本
+ * @param {string} base64Content - base64 编码的文件内容
+ * @returns {Promise<string>} 提取的文本内容
+ */
+async function extractTextFromDocxBase64(base64Content) {
+  try {
+    // 将 base64 转换为 Buffer
+    const buffer = Buffer.from(base64Content, 'base64');
+    
+    // 使用 mammoth 解析
+    const result = await mammoth.extractRawText({ buffer });
+    
+    // 清洗文本：移除多余空行，保留结构
+    const lines = result.value.split('\n');
+    const cleanedLines = [];
+    let lastWasEmpty = false;
+    
+    for (const line of lines) {
+      const trimmed = line.trim();
+      
+      if (trimmed.length === 0) {
+        if (!lastWasEmpty) {
+          cleanedLines.push('');
+          lastWasEmpty = true;
+        }
+      } else {
+        cleanedLines.push(trimmed);
+        lastWasEmpty = false;
+      }
+    }
+    
+    return cleanedLines.join('\n');
+  } catch (error) {
+    throw new Error(`解析 docx 文件失败: ${error.message}`);
+  }
+}
+
+/**
+ * 使用 AI 总结文档内容（流式输出）
+ * @param {Object} aiClient - AI 客户端实例
+ * @param {string} content - 文档原始内容
+ * @param {string} docType - 文档类型 (PRD 或 TD)
+ * @returns {Promise<string>} AI 生成的总结
+ */
+async function summarizeDocument(aiClient, content, docType) {
+  const docTypeNames = {
+    [DocumentType.PRD]: '产品需求文档',
+    [DocumentType.TD]: '技术设计文档',
+  };
+  
+  const prompts = {
+    [DocumentType.PRD]: `请仔细阅读以下产品需求文档，提取并总结关键信息。
+
+重点关注：
+1. 产品背景和目标
+2. 核心功能和特性
+3. 用户场景和需求
+4. 业务价值和优先级
+5. 产品边界和限制
+
+请用简洁的语言总结（300-500字），保留关键细节，便于后续代码审查时参考。
+
+产品需求文档内容：
+---
+${content}
+---
+
+请提供结构化的总结：`,
+    
+    [DocumentType.TD]: `请仔细阅读以下技术设计文档，提取并总结关键信息。
+
+重点关注：
+1. 技术架构和设计方案
+2. 核心模块和组件
+3. 技术选型和依赖
+4. 数据结构和接口设计
+5. 性能和安全考虑
+6. 技术难点和风险
+
+请用简洁的语言总结（300-500字），保留技术关键点，便于后续代码审查时参考。
+
+技术设计文档内容：
+---
+${content}
+---
+
+请提供结构化的总结：`,
+  };
+  
+  try {
+    const messages = [
+      {
+        role: 'system',
+        content: `你是一个专业的文档分析助手，擅长提取和总结${docTypeNames[docType]}的关键信息。请提供清晰、结构化的总结。`,
+      },
+      {
+        role: 'user',
+        content: prompts[docType],
+      },
+    ];
+    
+    console.log(`🤖 正在使用 AI 总结${docTypeNames[docType]}...`);
+    console.log('📥 AI 实时响应:');
+    console.log('-'.repeat(60));
+    
+    // 🎯 使用流式调用 AI（参考 config.js 的实现）
+    const response = await aiClient.sendMessageStream(messages, (chunk) => {
+      if (chunk.content) {
+        process.stdout.write(chunk.content);
+      }
+    });
+    
+    console.log('\n' + '-'.repeat(60));
+    const summary = response.content;
+    
+    if (!summary || summary.trim().length === 0) {
+      throw new Error('AI 返回了空的总结');
+    }
+    
+    console.log(`✅ ${docTypeNames[docType]}总结生成成功 (${summary.length} 字符)\n`);
+    
+    return summary.trim();
+  } catch (error) {
+    console.error(`❌ AI 总结失败: ${error.message}`);
+    // 返回原始内容的前 1000 字符作为降级方案
+    return `${docTypeNames[docType]}内容摘要（AI 总结失败，显示原始内容前 1000 字）：\n\n${content.substring(0, 1000)}${content.length > 1000 ? '...' : ''}`;
+  }
+}
+
+/**
+ * 加载项目文档
+ * @param {Object} options - 选项
+ * @param {Object} options.gitlabClient - GitLab 客户端实例
+ * @param {string} options.projectId - 项目 ID
+ * @param {string} options.ref - 分支名（默认 'main'）
+ * @param {Object} options.aiClient - AI 客户端实例（可选，用于生成总结）
+ * @param {string} options.documentsPath - documents 文件夹路径（默认 'documents'）
+ * @returns {Promise<Object>} 文档内容和总结
+ */
+export async function loadProjectDocuments(options = {}) {
+  const {
+    gitlabClient,
+    projectId,
+    ref = 'main',
+    aiClient = null,
+    documentsPath = 'documents',
+  } = options;
+  
+  if (!gitlabClient || !projectId) {
+    throw new Error('gitlabClient 和 projectId 是必需的参数');
+  }
+  
+  const result = {
+    prd: null,
+    td: null,
+    context: '', // 用于审查时携带的上下文
+  };
+  
+  console.log(`\n📚 开始加载项目文档 (路径: ${documentsPath}/)...`);
+  
+  // 文档配置
+  const docs = [
+    { type: DocumentType.PRD, filename: 'PRD.docx', name: '产品需求文档' },
+    { type: DocumentType.TD, filename: 'TD.docx', name: '技术设计文档' },
+  ];
+  
+  let loadedCount = 0;
+  const contextParts = [];
+  
+  for (const doc of docs) {
+    const filePath = `${documentsPath}/${doc.filename}`;
+    
+    try {
+      // 从 GitLab 获取文件（参考 gitlab-client.js 的 getProjectFile 方法）
+      console.log(`📄 尝试加载 ${doc.name} (${filePath})...`);
+      
+      // getProjectFile 返回的是文本内容，但对于二进制文件我们需要 base64
+      // 使用 GitLab API 的 raw 端点不适合二进制文件，需要使用带 encoding 的接口
+      const encodedPath = encodeURIComponent(filePath);
+      const response = await fetch(
+        `${gitlabClient.apiUrl}/projects/${encodeURIComponent(projectId)}/repository/files/${encodedPath}?ref=${ref}`,
+        {
+          headers: {
+            'PRIVATE-TOKEN': gitlabClient.token,
+          },
+        }
+      );
+      
+      if (!response.ok) {
+        if (response.status === 404) {
+          console.log(`⏭️  ${doc.name}不存在 (${filePath})，跳过`);
+          continue;
+        }
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      
+      const fileData = await response.json();
+      const base64Content = fileData.content;
+      
+      if (!base64Content) {
+        console.log(`⏭️  ${doc.name}内容为空，跳过`);
+        continue;
+      }
+      
+      // 解析 docx 文件
+      console.log(`🔄 正在解析 ${doc.name}...`);
+      const content = await extractTextFromDocxBase64(base64Content);
+      
+      console.log(`✅ ${doc.name}加载成功 (${content.length} 字符)`);
+      
+      // 使用 AI 生成总结（如果提供了 aiClient）
+      let summary = null;
+      if (aiClient) {
+        try {
+          summary = await summarizeDocument(aiClient, content, doc.type);
+        } catch (error) {
+          console.error(`⚠️  ${doc.name}总结生成失败: ${error.message}`);
+        }
+      }
+      
+      // 保存结果
+      if (doc.type === DocumentType.PRD) {
+        result.prd = {
+          content,
+          summary,
+          filename: doc.filename,
+          path: filePath,
+        };
+      } else if (doc.type === DocumentType.TD) {
+        result.td = {
+          content,
+          summary,
+          filename: doc.filename,
+          path: filePath,
+        };
+      }
+      
+      // 构建上下文
+      if (summary) {
+        contextParts.push(`## ${doc.name}\n\n${summary}`);
+      } else {
+        // 如果没有总结，使用原始内容的前 800 字符
+        const excerpt = content.substring(0, 800);
+        contextParts.push(`## ${doc.name}（摘录）\n\n${excerpt}${content.length > 800 ? '\n\n...(内容过长，已截断)' : ''}`);
+      }
+      
+      loadedCount++;
+    } catch (error) {
+      if (error.message && error.message.includes('404')) {
+        console.log(`⏭️  ${doc.name}不存在 (${filePath})，跳过`);
+      } else {
+        console.error(`❌ 加载 ${doc.name}时出错: ${error.message}`);
+      }
+    }
+  }
+  
+  // 生成最终上下文
+  if (loadedCount > 0) {
+    result.context = `# 📚 项目背景文档
+
+以下是项目的背景文档信息，在进行代码审查时请参考这些文档，确保代码实现符合产品需求和技术设计。
+
+${contextParts.join('\n\n---\n\n')}
+
+---
+
+请在审查代码时：
+1. 确保实现符合产品需求文档中的功能描述
+2. 遵循技术设计文档中的架构和设计原则
+3. 检查是否有遗漏或超出文档范围的实现
+4. 评估代码质量是否满足项目标准
+
+`;
+    console.log(`\n✅ 文档加载完成！共加载 ${loadedCount} 个文档`);
+  } else {
+    console.log(`\n⏭️  未找到任何项目文档，将在没有文档上下文的情况下进行审查`);
+  }
+  
+  return result;
+}
+
+/**
+ * 格式化文档上下文用于显示
+ * @param {Object} documents - 文档对象
+ * @returns {string} 格式化的文档信息
+ */
+export function formatDocumentsInfo(documents) {
+  const info = [];
+  
+  if (documents.prd) {
+    info.push(`📄 产品需求文档 (PRD.docx)`);
+    info.push(`   - 路径: ${documents.prd.path}`);
+    info.push(`   - 大小: ${documents.prd.content.length} 字符`);
+    if (documents.prd.summary) {
+      info.push(`   - 已生成 AI 总结: ${documents.prd.summary.length} 字符`);
+    }
+  }
+  
+  if (documents.td) {
+    info.push(`📄 技术设计文档 (TD.docx)`);
+    info.push(`   - 路径: ${documents.td.path}`);
+    info.push(`   - 大小: ${documents.td.content.length} 字符`);
+    if (documents.td.summary) {
+      info.push(`   - 已生成 AI 总结: ${documents.td.summary.length} 字符`);
+    }
+  }
+  
+  if (info.length === 0) {
+    return '未找到项目文档';
+  }
+  
+  return info.join('\n');
+}