gitlab-ai-review 4.2.4 → 6.3.9

package/lib/incremental-callchain-analyzer.js

@@ -1,811 +0,0 @@
-/**
- * 增量调用链分析器 - 基于 TypeScript Compiler API
- * 只分析 diff 中变更的符号及其调用链，避免全量分析
- */
-
-import ts from 'typescript';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-/**
- * 增量调用链分析器
- */
-export class IncrementalCallChainAnalyzer {
-  constructor(projectPath) {
-    this.projectPath = projectPath || process.env.CI_PROJECT_DIR || process.cwd();
-    this.program = null;
-    this.checker = null;
-    this.sourceFilesCache = new Map();
-    
-    console.log(`📁 项目路径: ${this.projectPath}`);
-  }
-  
-  /**
-   * 检查 TypeScript 环境是否可用
-   */
-  isAvailable() {
-    try {
-      // 检查项目路径是否存在
-      if (!fs.existsSync(this.projectPath)) {
-        console.warn(`⚠️  项目路径不存在: ${this.projectPath}`);
-        return false;
-      }
-      
-      // 检查是否有 TypeScript 文件
-      const hasTS = this.hasTypeScriptFiles();
-      if (!hasTS) {
-        console.warn('⚠️  项目中没有 TypeScript 文件');
-        return false;
-      }
-      
-      return true;
-    } catch (error) {
-      console.warn('⚠️  TypeScript 环境检查失败:', error.message);
-      return false;
-    }
-  }
-  
-  /**
-   * 检查项目是否有 TypeScript 文件
-   */
-  hasTypeScriptFiles() {
-    const extensions = ['.ts', '.tsx'];
-    
-    const checkDir = (dir, depth = 0) => {
-      if (depth > 3) return false; // 限制深度
-      if (dir.includes('node_modules')) return false;
-      
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        
-        for (const entry of entries) {
-          if (entry.isFile()) {
-            const ext = path.extname(entry.name);
-            if (extensions.includes(ext)) {
-              return true;
-            }
-          } else if (entry.isDirectory() && !entry.name.startsWith('.')) {
-            const subDir = path.join(dir, entry.name);
-            if (checkDir(subDir, depth + 1)) {
-              return true;
-            }
-          }
-        }
-      } catch (error) {
-        // 忽略权限错误
-      }
-      
-      return false;
-    };
-    
-    return checkDir(this.projectPath);
-  }
-  
-  /**
-   * 获取项目中受影响的文件列表（只分析必要的文件）
-   */
-  getAffectedFiles(changedFiles) {
-    const files = new Set();
-    
-    // 1. 添加变更文件本身
-    changedFiles.forEach(file => {
-      const fullPath = path.join(this.projectPath, file);
-      if (fs.existsSync(fullPath)) {
-        files.add(fullPath);
-      }
-    });
-    
-    // 2. 查找导入这些文件的文件（简单的文本搜索）
-    const allProjectFiles = this.getAllProjectFiles();
-    
-    for (const changedFile of changedFiles) {
-      const baseName = path.basename(changedFile, path.extname(changedFile));
-      const dirName = path.dirname(changedFile);
-      
-      for (const projectFile of allProjectFiles) {
-        try {
-          const content = fs.readFileSync(projectFile, 'utf8');
-          
-          // 检查是否导入了变更的文件
-          const importPatterns = [
-            new RegExp(`from\\s+['"]([^'"]*${baseName}[^'"]*)['"]`, 'g'),
-            new RegExp(`import\\s+['"]([^'"]*${baseName}[^'"]*)['"]`, 'g'),
-          ];
-          
-          const hasImport = importPatterns.some(pattern => pattern.test(content));
-          
-          if (hasImport) {
-            files.add(projectFile);
-          }
-        } catch (error) {
-          // 忽略读取错误
-        }
-      }
-    }
-    
-    console.log(`📂 需要分析的文件数: ${files.size}`);
-    return Array.from(files);
-  }
-  
-  /**
-   * 获取所有项目文件
-   */
-  getAllProjectFiles() {
-    const files = [];
-    const extensions = ['.ts', '.tsx', '.js', '.jsx'];
-    
-    const scanDir = (dir, depth = 0) => {
-      if (depth > 5) return; // 限制深度
-      if (dir.includes('node_modules')) return;
-      if (dir.includes('dist')) return;
-      if (dir.includes('build')) return;
-      if (dir.includes('.git')) return;
-      
-      try {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        
-        for (const entry of entries) {
-          if (entry.name.startsWith('.')) continue;
-          
-          const fullPath = path.join(dir, entry.name);
-          
-          if (entry.isFile()) {
-            const ext = path.extname(entry.name);
-            if (extensions.includes(ext)) {
-              files.push(fullPath);
-            }
-          } else if (entry.isDirectory()) {
-            scanDir(fullPath, depth + 1);
-          }
-        }
-      } catch (error) {
-        // 忽略权限错误
-      }
-    };
-    
-    scanDir(this.projectPath);
-    return files;
-  }
-  
-  /**
-   * 创建 TypeScript 程序（只解析必要的文件）
-   */
-  createProgram(files) {
-    console.log(`🔨 创建 TypeScript 程序...`);
-    const startTime = Date.now();
-    
-    // 查找 tsconfig.json
-    let configPath = path.join(this.projectPath, 'tsconfig.json');
-    if (!fs.existsSync(configPath)) {
-      configPath = path.join(this.projectPath, 'tsconfig.app.json');
-    }
-    
-    let compilerOptions = {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.ESNext,
-      jsx: ts.JsxEmit.React,
-      skipLibCheck: true,
-      skipDefaultLibCheck: true,
-      noEmit: true,
-      allowJs: true,
-      esModuleInterop: true,
-      resolveJsonModule: true,
-    };
-    
-    // 尝试加载 tsconfig
-    if (fs.existsSync(configPath)) {
-      try {
-        const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-        const parsedConfig = ts.parseJsonConfigFileContent(
-          configFile.config,
-          ts.sys,
-          this.projectPath
-        );
-        compilerOptions = { ...compilerOptions, ...parsedConfig.options };
-        console.log(`  ✅ 加载了 tsconfig: ${path.basename(configPath)}`);
-      } catch (error) {
-        console.warn(`  ⚠️  加载 tsconfig 失败，使用默认配置`);
-      }
-    }
-    
-    // 创建程序
-    this.program = ts.createProgram(files, compilerOptions);
-    this.checker = this.program.getTypeChecker();
-    
-    const duration = Date.now() - startTime;
-    console.log(`✅ TypeScript 程序创建完成 (${duration}ms)`);
-  }
-  
-  /**
-   * 分析变更的影响（核心方法）
-   */
-  async analyzeImpact(changedFiles, changedSymbols) {
-    console.log(`\n🔍 开始增量调用链分析...`);
-    
-    if (!this.isAvailable()) {
-      console.log('⚠️  TypeScript 环境不可用，跳过调用链分析');
-      return null;
-    }
-    
-    try {
-      // 1. 获取受影响的文件
-      const affectedFiles = this.getAffectedFiles(changedFiles);
-      
-      if (affectedFiles.length === 0) {
-        console.log('⚠️  没有找到受影响的文件');
-        return null;
-      }
-      
-      if (affectedFiles.length > 50) {
-        console.log(`⚠️  受影响的文件过多 (${affectedFiles.length})，跳过 TypeScript 分析`);
-        return null;
-      }
-      
-      // 2. 创建 TypeScript 程序
-      this.createProgram(affectedFiles);
-      
-      // 3. 为每个变更的符号构建调用链
-      const callChains = [];
-      
-      for (const symbol of changedSymbols.deleted) {
-        const chain = this.buildCallChain(symbol, changedFiles);
-        if (chain) {
-          callChains.push(chain);
-        }
-      }
-      
-      for (const symbol of changedSymbols.modified) {
-        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} 个调用链`);
-      
-      // 输出调用链摘要
-      if (callChains.length > 0) {
-        console.log(`\n📊 调用链摘要：`);
-        callChains.forEach((chain, idx) => {
-          const totalRefs = (chain.usages?.length || 0) + (chain.typeUsages?.length || 0);
-          const issueCount = chain.issues?.length || 0;
-          const issueInfo = issueCount > 0 ? ` ⚠️  ${issueCount} 个问题` : '';
-          console.log(`   ${idx + 1}. ${chain.symbol} (${chain.type}): ${totalRefs} 处引用${issueInfo}`);
-        });
-      }
-      
-      // 5. 提取代码上下文
-      const codeContext = this.extractCodeContext(callChains, changedFiles);
-      
-      return {
-        method: 'typescript-callchain',
-        callChains,
-        codeContext,
-        filesAnalyzed: affectedFiles.length,
-      };
-      
-    } catch (error) {
-      console.error('❌ 调用链分析失败:', error.message);
-      return null;
-    }
-  }
-  
-  /**
-   * 为单个符号构建调用链
-   */
-  buildCallChain(symbol, changedFiles) {
-    const symbolName = symbol.name || symbol;
-    const symbolType = symbol.type || 'unknown';
-    console.log(`  🔗 构建调用链: ${symbolName} (${symbolType})`);
-    
-    try {
-      // 1. 找到符号的所有引用
-      const references = this.findAllReferences(symbolName, symbolType);
-      
-      // 2. 如果是字段，额外查找父类型的使用
-      let typeUsages = [];
-      if (symbolType === 'field') {
-        typeUsages = this.findFieldParentTypeUsages(symbolName, changedFiles);
-      }
-      
-      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} 处直接引用, ${typeUsages.length} 处类型使用`);
-      
-      // 输出类型使用的详细位置
-      if (typeUsages.length > 0) {
-        console.log(`    📦 类型使用位置：`);
-        typeUsages.slice(0, 3).forEach((typeUsage, idx) => {
-          console.log(`       ${idx + 1}. ${typeUsage.file}:${typeUsage.line} - ${typeUsage.parentType}`);
-        });
-        if (typeUsages.length > 3) {
-          console.log(`       ... 还有 ${typeUsages.length - 3} 处`);
-        }
-      }
-      
-      // 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, 5),
-        };
-        
-        // 检测问题
-        const issue = this.detectIssue(ref, symbol);
-        if (issue) {
-          usage.issue = issue;
-        }
-        
-        // 追踪数据流
-        const dataFlow = this.traceDataFlow(ref.node);
-        if (dataFlow.length > 0) {
-          usage.dataFlow = dataFlow;
-        }
-        
-        return usage;
-      });
-      
-      const issues = usages.filter(u => u.issue).map(u => u.issue);
-      
-      // 输出直接引用的详细信息
-      if (references.length > 0) {
-        console.log(`    🔍 直接引用位置：`);
-        usages.slice(0, 3).forEach((usage, idx) => {
-          const issueInfo = usage.issue ? ` ⚠️  ${usage.issue.type}` : '';
-          const dataFlowInfo = usage.dataFlow && usage.dataFlow.length > 0 
-            ? ` → ${usage.dataFlow[usage.dataFlow.length - 1]}` 
-            : '';
-          console.log(`       ${idx + 1}. ${usage.file}:${usage.line}${issueInfo}${dataFlowInfo}`);
-        });
-        if (usages.length > 3) {
-          console.log(`       ... 还有 ${usages.length - 3} 处`);
-        }
-      }
-      
-      // 输出检测到的问题
-      if (issues.length > 0) {
-        console.log(`    🚨 检测到 ${issues.length} 个问题：`);
-        issues.forEach((issue, idx) => {
-          console.log(`       ${idx + 1}. [${issue.severity}] ${issue.message}`);
-        });
-      }
-      
-      return {
-        symbol: symbolName,
-        type: symbolType,
-        usages,
-        typeUsages,  // 新增：类型使用（如 mockData: Courseware[]）
-        issues,
-      };
-      
-    } catch (error) {
-      console.warn(`    ⚠️  构建调用链失败:`, error.message);
-      return null;
-    }
-  }
-  
-  /**
-   * 查找符号的所有引用
-   */
-  findAllReferences(symbolName, symbolType) {
-    const references = [];
-    
-    for (const sourceFile of this.program.getSourceFiles()) {
-      if (sourceFile.fileName.includes('node_modules')) continue;
-      
-      const content = sourceFile.getFullText();
-      
-      // 根据符号类型使用不同的搜索策略
-      if (symbolType === 'field') {
-        // 字段：搜索属性访问 obj.fieldName
-        const fieldAccessPattern = new RegExp(`\\.${symbolName}\\b`, 'g');
-        const objectLiteralPattern = new RegExp(`\\b${symbolName}\\s*:`, 'g');
-        
-        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: 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 节点
-   */
-  visitNode(node, callback) {
-    callback(node);
-    ts.forEachChild(node, (child) => this.visitNode(child, callback));
-  }
-  
-  /**
-   * 追踪数据流
-   */
-  traceDataFlow(node) {
-    const flow = [];
-    let current = node;
-    let depth = 0;
-    
-    while (current && depth < 5) {
-      if (ts.isVariableDeclaration(current)) {
-        const name = current.name.getText();
-        flow.unshift(`变量: ${name}`);
-      } else if (ts.isFunctionDeclaration(current)) {
-        const name = current.name?.getText() || 'anonymous';
-        flow.unshift(`函数: ${name}`);
-      } else if (ts.isPropertyAssignment(current)) {
-        const name = current.name.getText();
-        flow.unshift(`属性: ${name}`);
-      } else if (ts.isCallExpression(current)) {
-        const expr = current.expression.getText();
-        flow.unshift(`调用: ${expr}()`);
-      }
-      
-      current = current.parent;
-      depth++;
-    }
-    
-    return flow;
-  }
-  
-  /**
-   * 检测问题
-   */
-  detectIssue(reference, symbol) {
-    const line = this.getLineContent(reference.fileName, reference.line);
-    const symbolName = symbol.name || symbol;
-    
-    // 检测：访问被删除/重命名的符号
-    if (symbol.type === 'definition' && line.includes(symbolName)) {
-      // 检查是否是导入语句
-      if (line.includes('import') && line.includes(symbolName)) {
-        return {
-          type: 'import-deleted-symbol',
-          severity: 'error',
-          message: `导入了被删除的符号: ${symbolName}`,
-        };
-      }
-      
-      // 检查是否是函数调用
-      if (line.includes(`${symbolName}(`)) {
-        return {
-          type: 'call-deleted-function',
-          severity: 'error',
-          message: `调用了被删除的函数: ${symbolName}()`,
-        };
-      }
-      
-      // 检查是否是类型引用
-      if (line.includes(`: ${symbolName}`) || line.includes(`<${symbolName}>`)) {
-        return {
-          type: 'reference-deleted-type',
-          severity: 'error',
-          message: `引用了被删除的类型: ${symbolName}`,
-        };
-      }
-    }
-    
-    return null;
-  }
-  
-  /**
-   * 提取代码上下文
-   */
-  extractCodeContext(callChains, changedFiles) {
-    const filesMap = new Map();
-    
-    // 1. 提取直接引用
-    for (const chain of callChains) {
-      for (const usage of chain.usages) {
-        if (!filesMap.has(usage.file)) {
-          filesMap.set(usage.file, {
-            path: usage.file,
-            snippets: [],
-          });
-        }
-        
-        const fileInfo = filesMap.get(usage.file);
-        fileInfo.snippets.push({
-          symbol: chain.symbol,
-          line: usage.line,
-          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 {
-      files: Array.from(filesMap.values()),
-      totalFiles: filesMap.size,
-      totalIssues: callChains.flatMap(c => c.issues).length,
-      summary: this.buildSummary(callChains),
-    };
-  }
-  
-  /**
-   * 构建摘要
-   */
-  buildSummary(callChains) {
-    const summary = {
-      totalSymbols: callChains.length,
-      totalReferences: callChains.reduce((sum, c) => sum + c.usages.length, 0),
-      totalIssues: callChains.reduce((sum, c) => sum + c.issues.length, 0),
-      issuesByType: {},
-    };
-    
-    // 统计问题类型
-    for (const chain of callChains) {
-      for (const issue of chain.issues) {
-        const type = issue.type;
-        summary.issuesByType[type] = (summary.issuesByType[type] || 0) + 1;
-      }
-    }
-    
-    return summary;
-  }
-  
-  /**
-   * 获取相对路径
-   */
-  getRelativePath(filePath) {
-    return path.relative(this.projectPath, filePath);
-  }
-  
-  /**
-   * 获取行内容
-   */
-  getLineContent(fileName, lineNumber) {
-    try {
-      if (!this.sourceFilesCache.has(fileName)) {
-        const content = fs.readFileSync(fileName, 'utf8');
-        this.sourceFilesCache.set(fileName, content.split('\n'));
-      }
-      
-      const lines = this.sourceFilesCache.get(fileName);
-      return lines[lineNumber - 1] || '';
-    } catch (error) {
-      return '';
-    }
-  }
-  
-  /**
-   * 获取上下文（前后几行）
-   */
-  getContext(fileName, lineNumber, contextLines = 3) {
-    try {
-      if (!this.sourceFilesCache.has(fileName)) {
-        const content = fs.readFileSync(fileName, 'utf8');
-        this.sourceFilesCache.set(fileName, content.split('\n'));
-      }
-      
-      const lines = this.sourceFilesCache.get(fileName);
-      const start = Math.max(0, lineNumber - contextLines - 1);
-      const end = Math.min(lines.length, lineNumber + contextLines);
-      
-      return lines.slice(start, end).join('\n');
-    } catch (error) {
-      return '';
-    }
-  }
-}
-
-export default IncrementalCallChainAnalyzer;
-