gitlab-ai-review 2.5.3 → 3.0.0

package/lib/impact-analyzer.js

@@ -0,0 +1,455 @@
+/**
+ * 影响分析器 - 分析代码变更对其他文件的影响
+ */
+
+/**
+ * 从文件内容中提取导入/导出信息
+ * @param {string} content - 文件内容
+ * @param {string} fileName - 文件名
+ * @returns {Object} 导入导出信息
+ */
+export function extractImportsExports(content, fileName) {
+  const imports = [];
+  const exports = [];
+  
+  // JavaScript/TypeScript 导入
+  const importRegex = /import\s+(?:{([^}]+)}|(\w+)|\*\s+as\s+(\w+))\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    const namedImports = match[1] ? match[1].split(',').map(s => s.trim()) : [];
+    const defaultImport = match[2];
+    const namespaceImport = match[3];
+    const from = match[4];
+    
+    imports.push({
+      type: match[1] ? 'named' : match[2] ? 'default' : 'namespace',
+      names: namedImports,
+      default: defaultImport,
+      namespace: namespaceImport,
+      from: from,
+    });
+  }
+  
+  // 导出
+  const exportRegex = /export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+(\w+)/g;
+  while ((match = exportRegex.exec(content)) !== null) {
+    exports.push({
+      name: match[1],
+      line: content.substring(0, match.index).split('\n').length,
+    });
+  }
+  
+  // Vue 文件特殊处理
+  if (fileName.endsWith('.vue')) {
+    // 提取组件名
+    const componentNameMatch = content.match(/export\s+default\s+{[\s\S]*?name:\s*['"](\w+)['"]/);
+    if (componentNameMatch) {
+      exports.push({
+        name: componentNameMatch[1],
+        type: 'vue-component',
+        line: content.substring(0, componentNameMatch.index).split('\n').length,
+      });
+    }
+  }
+  
+  return { imports, exports };
+}
+
+/**
+ * 从 diff 中提取变更的函数/类/组件名称
+ * @param {string} diff - diff 内容
+ * @param {string} fileName - 文件名
+ * @returns {Object} 变更的符号列表 { added: [], deleted: [], modified: [] }
+ */
+export function extractChangedSymbols(diff, fileName) {
+  if (!diff) return { added: [], deleted: [], modified: [] };
+  
+  const addedSymbols = [];
+  const deletedSymbols = [];
+  const lines = diff.split('\n');
+  
+  // 匹配函数、类、常量定义
+  const definitionPatterns = [
+    /(?:export\s+)?(?:function|const|let|var)\s+(\w+)/,  // 函数/变量
+    /(?:export\s+)?class\s+(\w+)/,                       // 类
+    /(?:export\s+)?interface\s+(\w+)/,                   // 接口
+    /(?:export\s+)?type\s+(\w+)/,                        // 类型
+    /(?:export\s+)?enum\s+(\w+)/,                        // 枚举
+  ];
+  
+  lines.forEach((line, index) => {
+    const isAddition = line.startsWith('+') && !line.startsWith('+++');
+    const isDeletion = line.startsWith('-') && !line.startsWith('---');
+    
+    if (isAddition || isDeletion) {
+      const cleanLine = line.substring(1); // 移除 +/- 前缀
+      
+      // 检查定义
+      definitionPatterns.forEach(pattern => {
+        const match = cleanLine.match(pattern);
+        if (match) {
+          const symbol = {
+            name: match[1],
+            type: 'definition',
+            line: index + 1,
+          };
+          
+          if (isAddition) {
+            addedSymbols.push(symbol);
+          } else {
+            deletedSymbols.push(symbol);
+          }
+        }
+      });
+      
+      // 匹配函数调用
+      if (isAddition) {
+        const callPattern = /(\w+)\s*\(/g;
+        let callMatch;
+        while ((callMatch = callPattern.exec(cleanLine)) !== null) {
+          addedSymbols.push({
+            name: callMatch[1],
+            type: 'usage',
+            line: index + 1,
+          });
+        }
+      }
+    }
+  });
+  
+  // 找出被修改的符号（既被删除又被添加）
+  const modifiedSymbols = [];
+  const deletedNames = new Set(deletedSymbols.map(s => s.name));
+  const addedNames = new Set(addedSymbols.map(s => s.name));
+  
+  deletedNames.forEach(name => {
+    if (addedNames.has(name)) {
+      modifiedSymbols.push({ name, type: 'modified' });
+    }
+  });
+  
+  return {
+    added: addedSymbols,
+    deleted: deletedSymbols,
+    modified: modifiedSymbols,
+    all: [...addedSymbols, ...deletedSymbols], // 所有变更的符号
+  };
+}
+
+/**
+ * 检查文件内部是否使用了指定的符号
+ * @param {string} content - 文件内容
+ * @param {Array} symbols - 要检查的符号列表（通常是被删除的符号）
+ * @returns {Array} 文件内部使用情况
+ */
+export function checkInternalUsage(content, symbols) {
+  if (!content || !symbols || symbols.length === 0) {
+    return [];
+  }
+  
+  const usages = [];
+  const lines = content.split('\n');
+  
+  symbols.forEach(symbol => {
+    const symbolName = symbol.name || symbol;
+    const regex = new RegExp(`\\b${symbolName}\\b`, 'g');
+    
+    lines.forEach((line, index) => {
+      // 跳过定义行（避免匹配定义本身）
+      if (line.match(/(?:export\s+)?(?:function|const|let|var|class)\s+/) && 
+          line.includes(symbolName)) {
+        return;
+      }
+      
+      if (regex.test(line)) {
+        usages.push({
+          symbol: symbolName,
+          lineNumber: index + 1,
+          line: line.trim(),
+          context: {
+            before: lines.slice(Math.max(0, index - 2), index).map(l => l.trim()),
+            after: lines.slice(index + 1, index + 3).map(l => l.trim()),
+          },
+        });
+      }
+    });
+  });
+  
+  return usages;
+}
+
+/**
+ * 搜索项目中使用了指定符号的文件
+ * @param {Object} gitlabClient - GitLab 客户端
+ * @param {string} projectId - 项目 ID
+ * @param {string} ref - 分支名
+ * @param {Array} symbols - 要搜索的符号列表
+ * @returns {Promise<Array>} 使用了这些符号的文件列表
+ */
+export async function searchSymbolUsage(gitlabClient, projectId, ref, symbols) {
+  if (!symbols || symbols.length === 0) {
+    return [];
+  }
+  
+  const affectedFiles = new Map();
+  
+  // 对每个符号进行搜索
+  for (const symbol of symbols) {
+    try {
+      const symbolName = symbol.name || symbol;
+      // 使用 GitLab Search API 搜索代码
+      const searchResults = await gitlabClient.searchInProject(
+        projectId,
+        symbolName,
+        ref
+      );
+      
+      if (searchResults && searchResults.length > 0) {
+        searchResults.forEach(result => {
+          const key = result.path || result.filename;
+          if (!affectedFiles.has(key)) {
+            affectedFiles.set(key, {
+              path: key,
+              symbols: [],
+              lines: [],
+            });
+          }
+          
+          const fileInfo = affectedFiles.get(key);
+          fileInfo.symbols.push(symbolName);
+          if (result.startline) {
+            fileInfo.lines.push(result.startline);
+          }
+        });
+      }
+    } catch (error) {
+      console.warn(`搜索符号 ${symbol.name || symbol} 失败:`, error.message);
+    }
+  }
+  
+  return Array.from(affectedFiles.values());
+}
+
+/**
+ * 提取文件中特定符号周围的代码片段
+ * @param {string} content - 文件内容
+ * @param {string} symbolName - 符号名称
+ * @param {number} contextLines - 上下文行数
+ * @returns {Array} 代码片段数组
+ */
+export function extractCodeSnippets(content, symbolName, contextLines = 5) {
+  const lines = content.split('\n');
+  const snippets = [];
+  
+  lines.forEach((line, index) => {
+    if (line.includes(symbolName)) {
+      const start = Math.max(0, index - contextLines);
+      const end = Math.min(lines.length, index + contextLines + 1);
+      
+      snippets.push({
+        lineNumber: index + 1,
+        snippet: lines.slice(start, end).join('\n'),
+        startLine: start + 1,
+        endLine: end,
+      });
+    }
+  });
+  
+  return snippets;
+}
+
+/**
+ * 获取变更文件的函数/类签名
+ * @param {string} content - 文件内容
+ * @param {Array} changedSymbols - 变更的符号列表
+ * @returns {Array} 函数签名列表
+ */
+export function extractSignatures(content, changedSymbols) {
+  const signatures = [];
+  const lines = content.split('\n');
+  
+  changedSymbols.forEach(symbol => {
+    // 找到定义该符号的行
+    const definitionLineIndex = lines.findIndex(line => 
+      line.includes(`function ${symbol.name}`) ||
+      line.includes(`const ${symbol.name}`) ||
+      line.includes(`class ${symbol.name}`) ||
+      line.includes(`interface ${symbol.name}`)
+    );
+    
+    if (definitionLineIndex !== -1) {
+      // 提取函数签名（可能跨多行）
+      let signature = lines[definitionLineIndex];
+      let lineIndex = definitionLineIndex;
+      
+      // 如果没有找到完整的签名（例如没有 { 或 =>），继续往下找
+      while (lineIndex < lines.length - 1 && 
+             !signature.includes('{') && 
+             !signature.includes('=>') &&
+             !signature.includes(';')) {
+        lineIndex++;
+        signature += '\n' + lines[lineIndex];
+      }
+      
+      signatures.push({
+        name: symbol.name,
+        signature: signature.trim(),
+        lineNumber: definitionLineIndex + 1,
+      });
+    }
+  });
+  
+  return signatures;
+}
+
+/**
+ * 分析代码变更的完整影响
+ * @param {Object} options - 配置选项
+ * @param {Object} options.gitlabClient - GitLab 客户端
+ * @param {string} options.projectId - 项目 ID
+ * @param {string} options.ref - 分支名
+ * @param {Object} options.change - 代码变更对象
+ * @param {number} options.maxAffectedFiles - 最多分析的受影响文件数量
+ * @returns {Promise<Object>} 影响分析结果
+ */
+export async function analyzeImpact(options) {
+  const {
+    gitlabClient,
+    projectId,
+    ref,
+    change,
+    maxAffectedFiles = 10,
+  } = options;
+  
+  const fileName = change.new_path || change.old_path;
+  const diff = change.diff;
+  
+  console.log(`\n🔍 分析文件 ${fileName} 的影响...`);
+  
+  try {
+    // 1. 提取变更的符号（包括新增、删除、修改）
+    const changedSymbols = extractChangedSymbols(diff, fileName);
+    const totalSymbols = changedSymbols.all.length;
+    
+    console.log(`  发现变更符号: 新增 ${changedSymbols.added.length}, 删除 ${changedSymbols.deleted.length}, 修改 ${changedSymbols.modified.length}`);
+    
+    if (totalSymbols === 0) {
+      return {
+        fileName,
+        changedSymbols,
+        fileContent: null,
+        internalUsage: [],
+        affectedFiles: [],
+        signatures: [],
+      };
+    }
+    
+    // 2. 获取变更文件的完整内容
+    let fileContent = null;
+    let signatures = [];
+    let internalUsage = [];
+    
+    try {
+      fileContent = await gitlabClient.getProjectFile(projectId, fileName, ref);
+      if (fileContent) {
+        // 提取函数签名（针对新增和修改的符号）
+        const symbolsForSignature = [...changedSymbols.added, ...changedSymbols.modified];
+        if (symbolsForSignature.length > 0) {
+          signatures = extractSignatures(fileContent, symbolsForSignature);
+          console.log(`  提取了 ${signatures.length} 个函数签名`);
+        }
+        
+        // 检查文件内部是否使用了被删除的符号
+        if (changedSymbols.deleted.length > 0) {
+          internalUsage = checkInternalUsage(fileContent, changedSymbols.deleted);
+          if (internalUsage.length > 0) {
+            console.log(`  ⚠️  文件内部有 ${internalUsage.length} 处使用了被删除的符号`);
+          }
+        }
+      }
+    } catch (error) {
+      console.warn(`  无法获取文件内容:`, error.message);
+    }
+    
+    // 3. 搜索项目中使用了这些符号的其他文件
+    // 重点关注：被删除的符号、被修改的符号
+    const symbolsToSearch = [
+      ...changedSymbols.deleted.filter(s => s.type === 'definition'),
+      ...changedSymbols.modified,
+      ...changedSymbols.added.filter(s => s.type === 'definition'),
+    ];
+    
+    const affectedFiles = await searchSymbolUsage(
+      gitlabClient,
+      projectId,
+      ref,
+      symbolsToSearch
+    );
+    
+    // 过滤掉当前文件本身
+    const externalAffectedFiles = affectedFiles.filter(f => f.path !== fileName);
+    
+    console.log(`  找到 ${externalAffectedFiles.length} 个其他文件可能受影响`);
+    
+    // 4. 限制数量并获取代码片段
+    const limitedFiles = externalAffectedFiles.slice(0, maxAffectedFiles);
+    const filesWithSnippets = await Promise.all(
+      limitedFiles.map(async (file) => {
+        try {
+          const content = await gitlabClient.getProjectFile(projectId, file.path, ref);
+          
+          if (content) {
+            const snippets = [];
+            file.symbols.forEach(symbol => {
+              const symbolSnippets = extractCodeSnippets(content, symbol, 3);
+              snippets.push(...symbolSnippets);
+            });
+            
+            return {
+              ...file,
+              snippets: snippets.slice(0, 3), // 每个文件最多 3 个片段
+            };
+          }
+          
+          return file;
+        } catch (error) {
+          console.warn(`  无法获取文件 ${file.path} 的内容:`, error.message);
+          return file;
+        }
+      })
+    );
+    
+    return {
+      fileName,
+      changedSymbols,
+      fileContent,  // 完整文件内容
+      internalUsage, // 文件内部使用情况
+      signatures,
+      affectedFiles: filesWithSnippets,
+      totalAffectedFiles: externalAffectedFiles.length,
+    };
+    
+  } catch (error) {
+    console.error(`  影响分析失败:`, error.message);
+    return {
+      fileName,
+      error: error.message,
+      changedSymbols: { added: [], deleted: [], modified: [], all: [] },
+      fileContent: null,
+      internalUsage: [],
+      affectedFiles: [],
+      signatures: [],
+    };
+  }
+}
+
+export default {
+  extractImportsExports,
+  extractChangedSymbols,
+  checkInternalUsage,
+  searchSymbolUsage,
+  extractCodeSnippets,
+  extractSignatures,
+  analyzeImpact,
+};
+