gitlab-ai-review 4.2.1 → 4.2.3

package/lib/incremental-callchain-analyzer.js

@@ -252,23 +252,33 @@ export class IncrementalCallChainAnalyzer {
       const callChains = [];
       
       for (const symbol of changedSymbols.deleted) {
-        const chain = this.buildCallChain(symbol);
+        const chain = this.buildCallChain(symbol, changedFiles);
         if (chain) {
           callChains.push(chain);
         }
       }
       
       for (const symbol of changedSymbols.modified) {
-        const chain = this.buildCallChain(symbol);
+        const chain = this.buildCallChain(symbol, changedFiles);
         if (chain) {
           callChains.push(chain);
         }
       }
       
+      // 4. 新增：即使没有直接引用，也提取相关的类型使用
+      for (const symbol of changedSymbols.added) {
+        if (symbol.type === 'field') {
+          const chain = this.buildCallChain(symbol, changedFiles);
+          if (chain) {
+            callChains.push(chain);
+          }
+        }
+      }
+      
       console.log(`✅ 构建了 ${callChains.length} 个调用链`);
       
-      // 4. 提取代码上下文
-      const codeContext = this.extractCodeContext(callChains);
+      // 5. 提取代码上下文
+      const codeContext = this.extractCodeContext(callChains, changedFiles);
       
       return {
         method: 'typescript-callchain',
@@ -286,28 +296,46 @@ export class IncrementalCallChainAnalyzer {
   /**
    * 为单个符号构建调用链
    */
-  buildCallChain(symbol) {
+  buildCallChain(symbol, changedFiles) {
     const symbolName = symbol.name || symbol;
-    console.log(`  🔗 构建调用链: ${symbolName}`);
+    const symbolType = symbol.type || 'unknown';
+    console.log(`  🔗 构建调用链: ${symbolName} (${symbolType})`);
     
     try {
       // 1. 找到符号的所有引用
-      const references = this.findAllReferences(symbolName);
+      const references = this.findAllReferences(symbolName, symbolType);
+      
+      // 2. 如果是字段，额外查找父类型的使用
+      let typeUsages = [];
+      if (symbolType === 'field') {
+        typeUsages = this.findFieldParentTypeUsages(symbolName, changedFiles);
+      }
       
-      if (references.length === 0) {
+      if (references.length === 0 && typeUsages.length === 0) {
         console.log(`    ℹ️  未找到引用`);
+        // 对于字段，即使没找到引用，也返回基本信息
+        if (symbolType === 'field') {
+          return {
+            symbol: symbolName,
+            type: symbolType,
+            usages: [],
+            typeUsages: [],
+            issues: [],
+            note: '字段未被直接引用，但可能在类型定义中使用',
+          };
+        }
         return null;
       }
       
-      console.log(`    ✅ 找到 ${references.length} 处引用`);
+      console.log(`    ✅ 找到 ${references.length} 处直接引用, ${typeUsages.length} 处类型使用`);
       
-      // 2. 分析每个引用点
+      // 3. 分析每个引用点
       const usages = references.map(ref => {
         const usage = {
           file: this.getRelativePath(ref.fileName),
           line: ref.line,
           code: this.getLineContent(ref.fileName, ref.line),
-          context: this.getContext(ref.fileName, ref.line, 3),
+          context: this.getContext(ref.fileName, ref.line, 5),
         };
         
         // 检测问题
@@ -327,8 +355,9 @@ export class IncrementalCallChainAnalyzer {
       
       return {
         symbol: symbolName,
-        type: symbol.type || 'unknown',
+        type: symbolType,
         usages,
+        typeUsages,  // 新增：类型使用（如 mockData: Courseware[]）
         issues: usages.filter(u => u.issue).map(u => u.issue),
       };
       
@@ -341,32 +370,162 @@ export class IncrementalCallChainAnalyzer {
   /**
    * 查找符号的所有引用
    */
-  findAllReferences(symbolName) {
+  findAllReferences(symbolName, symbolType) {
     const references = [];
     
     for (const sourceFile of this.program.getSourceFiles()) {
       if (sourceFile.fileName.includes('node_modules')) continue;
       
-      this.visitNode(sourceFile, (node) => {
-        const text = node.getText();
+      const content = sourceFile.getFullText();
+      
+      // 根据符号类型使用不同的搜索策略
+      if (symbolType === 'field') {
+        // 字段：搜索属性访问 obj.fieldName
+        const fieldAccessPattern = new RegExp(`\\.${symbolName}\\b`, 'g');
+        const objectLiteralPattern = new RegExp(`\\b${symbolName}\\s*:`, 'g');
         
-        // 简单的文本匹配（比完整的符号解析快很多）
-        if (text === symbolName || text.includes(symbolName)) {
-          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-          
+        let match;
+        while ((match = fieldAccessPattern.exec(content)) !== null) {
+          const pos = match.index + 1; // +1 跳过 '.'
+          const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
           references.push({
             fileName: sourceFile.fileName,
             line: line + 1,
-            node: node,
+            node: this.getNodeAtPosition(sourceFile, pos),
             sourceFile: sourceFile,
+            matchType: 'field-access',
           });
         }
-      });
+        
+        while ((match = objectLiteralPattern.exec(content)) !== null) {
+          const pos = match.index;
+          const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+          references.push({
+            fileName: sourceFile.fileName,
+            line: line + 1,
+            node: this.getNodeAtPosition(sourceFile, pos),
+            sourceFile: sourceFile,
+            matchType: 'object-literal',
+          });
+        }
+      } else {
+        // 其他符号：简单的文本匹配
+        this.visitNode(sourceFile, (node) => {
+          const text = node.getText();
+          
+          if (text === symbolName || text.includes(symbolName)) {
+            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+            
+            references.push({
+              fileName: sourceFile.fileName,
+              line: line + 1,
+              node: node,
+              sourceFile: sourceFile,
+              matchType: 'text-match',
+            });
+          }
+        });
+      }
     }
     
     return references;
   }
   
+  /**
+   * 查找字段所属接口/类型的使用处
+   */
+  findFieldParentTypeUsages(fieldName, changedFiles) {
+    const typeUsages = [];
+    
+    try {
+      // 1. 找到字段所在的接口/类型定义
+      const parentTypes = this.findFieldParentTypes(fieldName, changedFiles);
+      
+      // 2. 对每个父类型，查找其使用处
+      for (const parentType of parentTypes) {
+        for (const sourceFile of this.program.getSourceFiles()) {
+          if (sourceFile.fileName.includes('node_modules')) continue;
+          
+          const content = sourceFile.getFullText();
+          
+          // 查找类型注解：const x: ParentType
+          const typeAnnotationPattern = new RegExp(`:\\s*${parentType}\\b`, 'g');
+          let match;
+          
+          while ((match = typeAnnotationPattern.exec(content)) !== null) {
+            const pos = match.index;
+            const { line } = sourceFile.getLineAndCharacterOfPosition(pos);
+            
+            typeUsages.push({
+              file: this.getRelativePath(sourceFile.fileName),
+              line: line + 1,
+              parentType: parentType,
+              context: this.getContext(sourceFile.fileName, line + 1, 8),
+              note: `使用了包含字段 ${fieldName} 的类型 ${parentType}`,
+            });
+          }
+        }
+      }
+      
+      console.log(`    📦 找到 ${typeUsages.length} 处使用父类型 ${parentTypes.join(', ')}`);
+    } catch (error) {
+      console.warn(`    ⚠️  查找父类型使用失败:`, error.message);
+    }
+    
+    return typeUsages;
+  }
+  
+  /**
+   * 查找字段所属的接口/类型名称
+   */
+  findFieldParentTypes(fieldName, changedFiles) {
+    const parentTypes = [];
+    
+    for (const changedFile of changedFiles) {
+      const fullPath = path.join(this.projectPath, changedFile);
+      if (!fs.existsSync(fullPath)) continue;
+      
+      const content = fs.readFileSync(fullPath, 'utf8');
+      
+      // 简单的正则：查找包含该字段的接口/类型
+      const interfacePattern = new RegExp(
+        `(?:export\\s+)?interface\\s+(\\w+)\\s*{[^}]*\\b${fieldName}\\s*[?]?\\s*:`,
+        'g'
+      );
+      const typePattern = new RegExp(
+        `(?:export\\s+)?type\\s+(\\w+)\\s*=\\s*{[^}]*\\b${fieldName}\\s*[?]?\\s*:`,
+        'g'
+      );
+      
+      let match;
+      while ((match = interfacePattern.exec(content)) !== null) {
+        parentTypes.push(match[1]);
+      }
+      while ((match = typePattern.exec(content)) !== null) {
+        parentTypes.push(match[1]);
+      }
+    }
+    
+    return [...new Set(parentTypes)];
+  }
+  
+  /**
+   * 获取指定位置的 AST 节点
+   */
+  getNodeAtPosition(sourceFile, position) {
+    let foundNode = sourceFile;
+    
+    const visit = (node) => {
+      if (node.pos <= position && position < node.end) {
+        foundNode = node;
+        ts.forEachChild(node, visit);
+      }
+    };
+    
+    visit(sourceFile);
+    return foundNode;
+  }
+  
   /**
    * 遍历 AST 节点
    */
@@ -448,9 +607,10 @@ export class IncrementalCallChainAnalyzer {
   /**
    * 提取代码上下文
    */
-  extractCodeContext(callChains) {
+  extractCodeContext(callChains, changedFiles) {
     const filesMap = new Map();
     
+    // 1. 提取直接引用
     for (const chain of callChains) {
       for (const usage of chain.usages) {
         if (!filesMap.has(usage.file)) {
@@ -467,8 +627,62 @@ export class IncrementalCallChainAnalyzer {
           code: usage.context,
           issue: usage.issue,
           dataFlow: usage.dataFlow,
+          type: 'direct-reference',
         });
       }
+      
+      // 2. 提取类型使用（针对字段）
+      if (chain.typeUsages && chain.typeUsages.length > 0) {
+        for (const typeUsage of chain.typeUsages) {
+          if (!filesMap.has(typeUsage.file)) {
+            filesMap.set(typeUsage.file, {
+              path: typeUsage.file,
+              snippets: [],
+            });
+          }
+          
+          const fileInfo = filesMap.get(typeUsage.file);
+          fileInfo.snippets.push({
+            symbol: chain.symbol,
+            line: typeUsage.line,
+            code: typeUsage.context,
+            note: typeUsage.note,
+            parentType: typeUsage.parentType,
+            type: 'type-usage',
+          });
+        }
+      }
+    }
+    
+    // 3. 始终包含变更文件本身的完整内容
+    for (const changedFile of changedFiles) {
+      const relativePath = changedFile.replace(this.projectPath, '').replace(/^[\/\\]/, '');
+      
+      if (!filesMap.has(relativePath)) {
+        filesMap.set(relativePath, {
+          path: relativePath,
+          snippets: [],
+        });
+      }
+      
+      const fileInfo = filesMap.get(relativePath);
+      
+      // 添加文件定义片段
+      try {
+        const fullPath = path.join(this.projectPath, changedFile);
+        if (fs.existsSync(fullPath)) {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          fileInfo.snippets.push({
+            symbol: '(文件定义)',
+            line: 1,
+            code: content,
+            type: 'file-definition',
+            note: '这是变更文件的完整内容，用于理解接口和类型定义',
+          });
+        }
+      } catch (error) {
+        console.warn(`    ⚠️  无法读取变更文件:`, error.message);
+      }
     }
     
     return {

package/package.json

@@ -1,50 +1,50 @@
-{
-  "name": "gitlab-ai-review",
-  "version": "4.2.1",
-  "description": "GitLab AI Review SDK with TypeScript Call Chain Analysis - 支持 TypeScript 增量调用链分析、影响分析、删除符号检测、注释代码识别、文件内部冲突检查、智能文件过滤的智能代码审查工具",
-  "main": "index.js",
-  "type": "module",
-  "bin": {
-    "gitlab-ai-review": "./cli.js"
-  },
-  "scripts": {
-    "test": "node test-info.js",
-    "test:info": "node test-info.js"
-  },
-  "files": [
-    "index.js",
-    "cli.js",
-    "lib/",
-    "test-info.js",
-    "README.md"
-  ],
-  "keywords": [
-    "gitlab",
-    "ai",
-    "review",
-    "code-review",
-    "sdk",
-    "ci-cd",
-    "impact-analysis",
-    "static-analysis",
-    "merge-request",
-    "automation"
-  ],
-  "author": "dengjiang1",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/dengjiang1/gitlab-ai-review.git"
-  },
-  "bugs": {
-    "url": "https://github.com/dengjiang1/gitlab-ai-review/issues"
-  },
-  "homepage": "https://github.com/dengjiang1/gitlab-ai-review#readme",
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "openai": "^4.73.0",
-    "typescript": "^5.3.3"
-  }
-}
+{
+  "name": "gitlab-ai-review",
+  "version": "4.2.3",
+  "description": "GitLab AI Review SDK with TypeScript Call Chain Analysis - 支持 TypeScript 增量调用链分析、影响分析、删除符号检测、注释代码识别、文件内部冲突检查、智能文件过滤的智能代码审查工具",
+  "main": "index.js",
+  "type": "module",
+  "bin": {
+    "gitlab-ai-review": "./cli.js"
+  },
+  "scripts": {
+    "test": "node test-info.js",
+    "test:info": "node test-info.js"
+  },
+  "files": [
+    "index.js",
+    "cli.js",
+    "lib/",
+    "test-info.js",
+    "README.md"
+  ],
+  "keywords": [
+    "gitlab",
+    "ai",
+    "review",
+    "code-review",
+    "sdk",
+    "ci-cd",
+    "impact-analysis",
+    "static-analysis",
+    "merge-request",
+    "automation"
+  ],
+  "author": "dengjiang1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dengjiang1/gitlab-ai-review.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dengjiang1/gitlab-ai-review/issues"
+  },
+  "homepage": "https://github.com/dengjiang1/gitlab-ai-review#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "openai": "^4.73.0",
+    "typescript": "^5.3.3"
+  }
+}