smart-review 1.0.1 → 1.0.2

package/lib/reviewer.js

@@ -9,6 +9,7 @@ import { GitDiffParser } from './utils/git-diff-parser.js';
 import { logger } from './utils/logger.js';
 import { DEFAULT_CONFIG, BATCH_CONSTANTS } from './utils/constants.js';
 import { ConcurrencyLimiter } from './utils/concurrency-limiter.js';
+import { t } from './utils/i18n.js';
 
 const execAsync = promisify(exec);
 
@@ -16,8 +17,8 @@ export class CodeReviewer {
   constructor(config, rules) {
     this.config = config;
     this.rules = rules;
-    // 传递 reviewDir 给 AI 客户端用于读取自定义提示词目录 .smart-review/ai-rules
-    this.aiClient = config.ai?.enabled ? new AIClient({ ...config.ai, reviewDir: config.reviewDir }) : null;
+    // 传递 reviewDir 与 locale 给 AI 客户端用于读取自定义提示词目录与国际化
+    this.aiClient = config.ai?.enabled ? new AIClient({ ...config.ai, reviewDir: config.reviewDir, locale: config.locale }) : null;
     this.issues = [];
     this.aiRan = false;
     
@@ -61,42 +62,42 @@ export class CodeReviewer {
 
   async reviewStagedFiles() {
     try {
-      logger.progress('开始审查暂存区代码...');
+      logger.progress(t(this.config, 'review_staged_start'));
       
       // 检查是否启用git diff增量审查模式
       const reviewOnlyChanges = this.config.ai?.reviewOnlyChanges || false;
       
       if (reviewOnlyChanges) {
-        logger.info('🔍 使用Git Diff增量审查模式 - 仅审查变动内容');
+        logger.info(t(this.config, 'using_diff_mode'));
         return await this.reviewStagedDiff();
       } else {
-        logger.info('📁 使用全文件审查模式');
+        logger.info(t(this.config, 'using_full_mode'));
         const stagedFiles = await this.getStagedFiles();
         
         if (stagedFiles.length === 0) {
-          logger.info('📭 暂存区没有文件需要审查');
+          logger.info(t(this.config, 'no_staged_files'));
           return this.generateResult();
         }
-        logger.info(`📁 发现 ${stagedFiles.length} 个文件需要审查`);
+        logger.info(t(this.config, 'found_staged_files_n', { count: stagedFiles.length }));
         
         await this.reviewFilesBatchAware(stagedFiles);
         return this.generateResult();
       }
     } catch (error) {
-      logger.error('审查过程出错:', error);
+      logger.error(t(this.config, 'review_error', { error: error?.message || String(error) }));
       throw error;
     }
   }
 
   async reviewSpecificFiles(filePaths) {
-    logger.progress(`开始审查指定文件: ${filePaths.join(', ')}`);
+    logger.progress(t(this.config, 'review_specific_start', { files: filePaths.join(', ') }));
     const fullPaths = [];
     for (const filePath of filePaths) {
       const fullPath = path.isAbsolute(filePath) ? filePath : path.join(this.config.projectRoot, filePath);
       if (fs.existsSync(fullPath)) {
         fullPaths.push(fullPath);
       } else {
-        logger.warn(`文件不存在: ${fullPath}`);
+        logger.warn(t(this.config, 'file_not_exists', { file: fullPath }));
       }
     }
     await this.reviewFilesBatchAware(fullPaths);
@@ -114,7 +115,7 @@ export class CodeReviewer {
         .map(file => path.resolve(this.config.projectRoot, file))
         .filter(file => this.isReviewableFile(file));
     } catch (error) {
-      logger.error('获取暂存区文件失败:', error);
+      logger.error(t(this.config, 'get_staged_failed', { error: error?.message || String(error) }));
       return [];
     }
   }
@@ -124,7 +125,7 @@ export class CodeReviewer {
    */
   async reviewStagedDiff() {
     try {
-      logger.info('🔍 启动Git Diff增量审查模式...');
+      logger.info(t(this.config, 'start_git_diff_mode'));
       
       const contextMergeLines = this.config.ai?.contextMergeLines || 10;
       const diffParser = new GitDiffParser(this.config.projectRoot, contextMergeLines, this.config);
@@ -133,11 +134,10 @@ export class CodeReviewer {
       const diffReviewData = await diffParser.getStagedDiffReviewData();
       
       if (diffReviewData.length === 0) {
-        logger.info('📝 暂存区无变更内容，跳过审查');
+        logger.info(t(this.config, 'no_changes_skip'));
         return this.generateResult();
       }
-
-      logger.info(`📊 发现 ${diffReviewData.length} 个变更文件，开始增量审查...`);
+      logger.info(t(this.config, 'found_changed_files_n', { count: diffReviewData.length }));
       
       // 第一阶段：对所有文件进行静态规则检查，检测阻断风险
       const riskLevels = this.config.riskLevels || {};
@@ -149,16 +149,22 @@ export class CodeReviewer {
         const globalIndex = i + 1;
         const filePath = path.resolve(this.config.projectRoot, fileData.filePath);
         if (!this.isReviewableFile(filePath)) {
-          logger.info(`文件已跳过审查: ${filePath} (文件类型被忽略)`);
+          logger.info(t(this.config, 'file_skipped_by_type', { path: filePath }));
           continue;
         }
-        logger.progress(`[${globalIndex}/${diffReviewData.length}] 审查文件: ${fileData.filePath} (新增${fileData.totalAddedLines}行, ${fileData.segments.length}个分段)`);
+        logger.progress(t(this.config, 'review_file_progress', {
+          index: globalIndex,
+          total: diffReviewData.length,
+          file: fileData.filePath,
+          added: fileData.totalAddedLines,
+          segments: fileData.segments.length
+        }));
         // 应用静态规则检查
         const staticIssues = await this.applyStaticRulesToDiff(fileData, filePath);
         this.issues.push(...staticIssues);
         
         if (staticIssues.length > 0) {
-          logger.debug(`静态规则发现 ${staticIssues.length} 个问题`);
+          logger.debug(t(this.config, 'static_rules_found_n_dbg', { count: staticIssues.length }));
         }
 
         // 检查是否有阻断等级问题
@@ -169,7 +175,7 @@ export class CodeReviewer {
 
         if (blockedIssues.length > 0) {
           const levelsText = [...new Set(blockedIssues.map(i => i.risk))].join(', ');
-          logger.error(`发现阻断等级风险 (${levelsText})，跳过AI分析`);
+          logger.error(t(this.config, 'blocking_risk_detected_skip_ai', { levels: levelsText }));
           hasBlockingIssues = true;
         } else {
           // 没有阻断问题的文件可以进行AI分析
@@ -179,13 +185,13 @@ export class CodeReviewer {
       
       // 如果发现阻断等级问题，终止整个审查流程
       if (hasBlockingIssues) {
-        logger.error('发现阻断等级风险，终止审查流程');
+        logger.error(t(this.config, 'blocking_risk_terminate'));
         return this.generateResult();
       }
       
       // 第二阶段：对通过静态检查的文件进行AI分析
       if (aiEligibleFiles.length > 0 && this.aiClient) {
-        logger.info(`🤖 开始AI智能分析 ${aiEligibleFiles.length} 个文件...`);
+        logger.info(t(this.config, 'ai_start_n_files', { count: aiEligibleFiles.length }));
         
         // 使用并发处理AI分析
         const concurrency = this.config.concurrency || 3;
@@ -204,7 +210,7 @@ export class CodeReviewer {
           // 并发处理当前批次的文件
           const promises = batch.map((fileData, index) => {
             const globalIndex = batchIndex * concurrency + index + 1;
-            logger.debug(`  🤖 [${globalIndex}/${aiEligibleFiles.length}] AI分析: ${fileData.filePath}`);
+            logger.debug(t(this.config, 'ai_file_progress_dbg', { index: globalIndex, total: aiEligibleFiles.length, file: fileData.filePath }));
             return this.performAIDiffAnalysis(fileData);
           });
           
@@ -212,11 +218,11 @@ export class CodeReviewer {
         }
       }
       
-      logger.success('✨ Git Diff增量审查完成');
+      logger.success(t(this.config, 'git_diff_done'));
 
       return this.generateResult();
     } catch (error) {
-      logger.error('Git Diff审查过程出错:', error);
+      logger.error(t(this.config, 'git_diff_error', { error: error?.message || String(error) }));
       throw error;
     }
   }
@@ -229,18 +235,18 @@ export class CodeReviewer {
     const filePath = path.resolve(this.config.projectRoot, fileData.filePath);
     
     if (!this.isReviewableFile(filePath)) {
-      logger.info(`文件已跳过审查: ${filePath} (文件类型被忽略)`);
+      logger.info(t(this.config, 'file_skipped_by_type', { path: filePath }));
       return;
     }
 
     try {
       // 1. 对新增代码应用静态规则
-      logger.debug(`应用静态规则检查...`);
+      logger.debug(t(this.config, 'apply_static_rules_dbg'));
       const staticIssues = await this.applyStaticRulesToDiff(fileData, filePath);
       this.issues.push(...staticIssues);
       
       if (staticIssues.length > 0) {
-        logger.debug(`静态规则发现 ${staticIssues.length} 个问题`);
+        logger.debug(t(this.config, 'static_rules_found_n_dbg', { count: staticIssues.length }));
       }
 
       // 2. 本地规则门槛判定
@@ -252,23 +258,23 @@ export class CodeReviewer {
 
       if (blockedIssues.length > 0) {
         const levelsText = [...new Set(blockedIssues.map(i => i.risk))].join(', ');
-        logger.error(`发现阻断等级风险 (${levelsText})，跳过AI分析`);
+        logger.error(t(this.config, 'blocking_risk_detected_skip_ai', { levels: levelsText }));
       } else {
         // 3. 应用AI分析（如果启用）
         if (this.aiClient && this.shouldUseAI(filePath, fileData.fullContent)) {
-          logger.debug(`启动AI智能分析...`);
+          logger.debug(t(this.config, 'ai_start_progress_note'));
           const aiIssues = await this.aiClient.analyzeDiffFile(fileData, { staticIssues });
           this.issues.push(...aiIssues);
           this.aiRan = true;
           
           if (aiIssues.length > 0) {
-            logger.debug(`AI分析发现 ${aiIssues.length} 个问题`);
+            logger.debug(t(this.config, 'ai_issues_found_n_dbg', { count: aiIssues.length }));
           }
         }
       }
 
     } catch (error) {
-       logger.error(`审查文件变更失败 ${filePath}:`, error);
+       logger.error(t(this.config, 'review_file_failed', { file: filePath, error: error?.message || String(error) }));
      }
    }
 
@@ -282,17 +288,17 @@ export class CodeReviewer {
      
      try {
        if (this.aiClient && this.shouldUseAI(filePath, fileData.fullContent)) {
-         logger.debug(`启动AI智能分析...`);
+         logger.debug(t(this.config, 'ai_start_progress_note'));
          const aiIssues = await this.aiClient.analyzeDiffFile(fileData, { staticIssues });
          this.issues.push(...aiIssues);
          this.aiRan = true;
          
          if (aiIssues.length > 0) {
-           logger.debug(`AI分析发现 ${aiIssues.length} 个问题`);
+           logger.debug(t(this.config, 'ai_issues_found_n_dbg', { count: aiIssues.length }));
          }
        }
      } catch (error) {
-       logger.error(`AI分析文件变更失败 ${filePath}:`, error);
+       logger.error(t(this.config, 'ai_diff_failed', { path: filePath, error: error?.message || String(error) }));
      }
    }
 
@@ -359,7 +365,61 @@ export class CodeReviewer {
            const regex = this.getCachedRegex(rule.pattern, rule.flags || 'gm');
            let match;
            const reportedSnippets = new Set();
-
+           const requiresAbsent = Array.isArray(rule.requiresAbsent) ? rule.requiresAbsent : null;
+           const isPairable = !!(requiresAbsent && requiresAbsent.some(s => /\(/.test(String(s))));
+           const escapeRegExp = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+           const findAssignedHandleBefore = (src, mIndex) => {
+             const lineStart = src.lastIndexOf('\n', Math.max(0, mIndex - 1)) + 1;
+             const left = src.slice(lineStart, mIndex);
+             const assignMatch = /([A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)*)\s*(?:=|:=)\s*$/.exec(left);
+             if (assignMatch) return assignMatch[1];
+             return null;
+           };
+           const isEffectiveIndex = (idx) => {
+             if (this.isIndexInRanges(idx, commentRanges)) return false;
+             if (this.isIndexInRanges(idx, disableRanges.suppressRanges || [])) return false;
+             return true;
+           };
+           const buildPairedCleanupRegexes = (rxStr, handle, flags) => {
+             const raw = String(rxStr);
+             if (!/(\(|\\\()/.test(raw)) return [];
+             const escapedHandle = escapeRegExp(handle);
+             const fFlags = flags || 'gm';
+             const out = [];
+             // 1) 函数调用样式：fnName( handle )
+             try {
+               const withHandle = raw.replace(/\\\(/, `\\(\\s*${escapedHandle}\\s*`);
+               const patternStr = withHandle.endsWith(')') || /\\\)\s*$/.test(withHandle) ? withHandle : `${withHandle}\\)`;
+               out.push(new RegExp(patternStr, fFlags));
+             } catch (_) {}
+             // 2) 句柄方法样式：handle.fnName(...)
+             try {
+               const fnMatch = raw.match(/([A-Za-z_][A-Za-z0-9_.$]*)\s*(?:\\\(|\()/);
+               if (fnMatch) {
+                 const fn = escapeRegExp(fnMatch[1]);
+                 out.push(new RegExp(`${escapedHandle}\\s*\\.\\s*${fn}\\s*\\(`, fFlags));
+               }
+             } catch (_) {}
+             return out;
+           };
+
+           // 非配对规则：若 requiresAbsent 存在且在新增内容中命中有效清理，则跳过该规则在此段
+           if (!isPairable && requiresAbsent && requiresAbsent.length > 0) {
+             let hasCleanup = false;
+             for (const rxStr of requiresAbsent) {
+               try {
+                 const rx = this.getCachedRegex(rxStr, rule.flags || 'gm');
+                 let cm;
+                 while ((cm = rx.exec(addedLinesContent)) !== null) {
+                   if (isEffectiveIndex(cm.index)) { hasCleanup = true; break; }
+                 }
+               } catch (_) {}
+               if (hasCleanup) break;
+             }
+             if (hasCleanup) {
+               continue;
+             }
+           }
            while ((match = regex.exec(addedLinesContent)) !== null) {
              // 检查匹配位置是否在注释中
              if (this.isIndexInRanges(match.index, commentRanges)) {
@@ -371,6 +431,29 @@ export class CodeReviewer {
                continue;
              }
              
+             // 当规则的 requiresAbsent 是“函数调用样式”时：对每个匹配执行句柄级清理配对
+             if (isPairable && requiresAbsent && requiresAbsent.length > 0) {
+               const handle = findAssignedHandleBefore(addedLinesContent, match.index);
+               let cleaned = false;
+               if (handle) {
+                 for (const rxStr of requiresAbsent) {
+                   const pairedRegexes = buildPairedCleanupRegexes(rxStr, handle, rule.flags);
+                   if (!pairedRegexes || pairedRegexes.length === 0) continue;
+                   for (const pairedRx of pairedRegexes) {
+                     let cm;
+                     while ((cm = pairedRx.exec(addedLinesContent)) !== null) {
+                       if (isEffectiveIndex(cm.index)) { cleaned = true; break; }
+                     }
+                     if (cleaned) break;
+                   }
+                   if (cleaned) break;
+                 }
+               }
+               if (cleaned) {
+                 continue; // 已对同一句柄执行清理，不报警
+               }
+             }
+
              const snippetText = (match[0] || '').substring(0, 200); // 限制片段长度
              
              if (reportedSnippets.has(snippetText)) {
@@ -399,7 +482,7 @@ export class CodeReviewer {
              }
            }
          } catch (error) {
-           logger.warn(`规则 ${rule.id} 在diff模式下执行失败:`, error.message);
+           logger.warn(t(this.config, 'rule_diff_exec_failed_warn', { id: rule.id, error: error?.message || String(error) }));
          }
        }
      }
@@ -426,33 +509,54 @@ export class CodeReviewer {
      return addedLines;
    }
 
-   /**
-    * 从段落中提取新增行内容和行号映射
-    * @param {Object} segment 代码段
-    * @returns {Object} { addedLinesContent: string, lineMapping: Array }
-    */
-   extractAddedLinesFromSegment(segment) {
-     const lines = segment.content.split('\n');
-     const addedLines = [];
-     const lineMapping = []; // 映射：新内容行号 -> 原始段落行号
-     
-     for (let i = 0; i < lines.length; i++) {
-       const line = lines[i];
-       // 只提取新增行（以+开头的行）
-       if (line.startsWith('+')) {
-         // 移除+前缀，保留实际代码内容
-         addedLines.push(line.substring(1));
-         lineMapping.push(i + 1); // 记录在原始段落中的行号（1-based）
-       }
-     }
-     
-     return {
-       addedLinesContent: addedLines.join('\n'),
-       lineMapping
-     };
-   }
+  /**
+   * 从段落中提取新增行内容和行号映射
+   * @param {Object} segment 代码段
+   * @returns {Object} { addedLinesContent: string, lineMapping: Array, originalAddedLinesContent: string }
+   */
+  extractAddedLinesFromSegment(segment) {
+    const lines = segment.content.split('\n');
+    const addedLinesOriginal = [];
+    const addedLinesNormalized = [];
+    const lineMapping = []; // 新内容行号(1-based) -> 原文件行号
+    const bracketRe = /^\s*\[\s*(\d+)\s*\]\s*/; // 解析类似 "[2067] " 的前缀
+    let plusIdx = 0; // 计数第几条新增行
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      // 只提取新增行（以+开头的行）
+      if (line.startsWith('+')) {
+        const withoutPlus = line.substring(1);
+        addedLinesOriginal.push(withoutPlus);
+
+        // 优先使用 segment.addedLineNumbers 提供的真实文件行号
+        let actualLine = Array.isArray(segment.addedLineNumbers) && plusIdx < segment.addedLineNumbers.length
+          ? segment.addedLineNumbers[plusIdx]
+          : undefined;
+        // 若未提供，则尝试从 [行号] 前缀中解析
+        if (!Number.isFinite(actualLine)) {
+          const m = withoutPlus.match(bracketRe);
+          if (m) actualLine = parseInt(m[1], 10);
+        }
+        // 兜底：用段起始行近似（不理想，但避免 undefined）
+        if (!Number.isFinite(actualLine)) {
+          actualLine = Number.isFinite(segment?.startLine) ? (segment.startLine + plusIdx) : undefined;
+        }
+        lineMapping.push(actualLine);
 
+        // 生成用于匹配的规范化行：移除 [行号] 前缀
+        const normalized = withoutPlus.replace(bracketRe, '');
+        addedLinesNormalized.push(normalized);
+        plusIdx++;
+      }
+    }
 
+    return {
+      addedLinesContent: addedLinesNormalized.join('\n'),
+      lineMapping,
+      originalAddedLinesContent: addedLinesOriginal.join('\n')
+    };
+  }
 
   // 批量感知：优先批量AI分析（方案A），同时保留静态规则与阻断判定
   async reviewFilesBatchAware(filePaths) {
@@ -463,11 +567,11 @@ export class CodeReviewer {
 
     for (const file of filePaths) {
       if (!this.isReviewableFile(file)) {
-        logger.info(`文件已跳过审查: ${file} (文件类型被忽略)`);
+        logger.info(t(this.config, 'file_skipped_by_type', { path: file }));
         continue;
       }
       const relativePath = path.relative(this.config.projectRoot, file);
-      logger.debug(`审查文件: ${relativePath}`);
+      logger.debug(t(this.config, 'review_file_dbg', { file: relativePath }));
 
       try {
         const content = await this.getFileContent(file);
@@ -493,19 +597,19 @@ export class CodeReviewer {
           aiEligible.push({ filePath: file, content, staticIssues: contextStatic });
         }
       } catch (error) {
-          logger.error(`审查文件失败 ${file}:`, error);
+          logger.error(t(this.config, 'review_file_failed', { file, error: error?.message || String(error) }));
         }
       }
     // 若任意文件存在阻断等级问题，直接返回（跳过AI）
     if (anyBlocking) {
-      logger.info('本地规则存在阻断等级风险，跳过所有文件的AI分析。');
+      logger.info(t(this.config, 'blocking_risk_skip_all_ai_info'));
       return;
     }
 
     if (aiEligible.length === 0) return;
 
     // 使用增量式分析器进行分析（默认行为）
-    logger.progress('使用增量式分析器进行分析...');
+    logger.progress(t(this.config, 'using_incremental_analyzer_progress'));
     await this.reviewFilesWithIncrementalAnalyzer(aiEligible);
   }
 
@@ -515,7 +619,7 @@ export class CodeReviewer {
       await this.reviewFilesWithSmartBatching(aiEligible);
       
     } catch (error) {
-      logger.error(`增量式分析器失败: ${error.message}`);
+      logger.error(t(this.config, 'incremental_analyzer_failed_error', { error: error?.message || String(error) }));
       throw error;
     }
   }
@@ -533,7 +637,7 @@ export class CodeReviewer {
         chunkOverlapLines: batchCfg.chunkOverlapLines || 5
       });
 
-      logger.progress('开始AI智能分析，根据文件大小耗时不同，请耐心等待...');
+      logger.progress(t(this.config, 'ai_smart_analysis_start_progress'));
       const batchResult = smartBatching.createSmartBatches(aiEligible);
 
       if (this.useConcurrency && this.aiClientPool) {
@@ -547,10 +651,10 @@ export class CodeReviewer {
       
       this.aiRan = true;
     } catch (error) {
-      logger.error('AI智能批量分析过程出错:', error);
+      logger.error(t(this.config, 'smart_batching_process_error', { error: error?.message || String(error) }));
       
       // 回退到原有的简单分批方式
-      logger.progress('回退到简单分析方式...');
+      logger.progress(t(this.config, 'fallback_simple_analysis_progress'));
       try {
         const max = Number(batchCfg.maxFilesPerBatch || 20);
         const batches = [];
@@ -558,18 +662,18 @@ export class CodeReviewer {
           batches.push(aiEligible.slice(i, i + max));
         }
         
-        logger.info(`开始AI分析，共${batches.length}批文件`);
+        logger.info(t(this.config, 'ai_analysis_start_batches', { count: batches.length }));
         
         for (let i = 0; i < batches.length; i++) {
           const batch = batches[i];
-          logger.info(`批次 ${i + 1}/${batches.length}: 分析${batch.length}个文件`);
+          logger.info(t(this.config, 'batch_info_header', { index: i + 1, total: batches.length, files: batch.length }));
           const aiIssues = await this.aiClient.analyzeFilesBatch(batch);
           this.issues.push(...aiIssues);
-          logger.success(`批次 ${i + 1}/${batches.length} 完成`);
+          logger.success(t(this.config, 'batch_done_success', { index: i + 1, total: batches.length }));
         }
         this.aiRan = true;
       } catch (fallbackError) {
-        logger.error('回退分析也失败:', fallbackError);
+        logger.error(t(this.config, 'fallback_analysis_failed', { error: fallbackError?.message || String(fallbackError) }));
       }
     }
   }
@@ -582,8 +686,8 @@ export class CodeReviewer {
   async processBatchesConcurrently(batches, smartBatching) {
     // 只有当批次数量大于1且并发数量大于1时才显示并发处理日志
     if (batches.length > 1 && this.concurrency > 1) {
-      logger.info(`启用并发处理，并发数: ${this.concurrency}`);
-      logger.info(`使用并发模式处理 ${batches.length} 个批次`);
+      logger.info(t(this.config, 'start_concurrency_enabled_info', { concurrency: this.concurrency }));
+      logger.info(t(this.config, 'start_concurrency_dbg', { count: batches.length }));
     }
     
     // 创建进度跟踪器
@@ -600,7 +704,7 @@ export class CodeReviewer {
         progressTracker.completed++;
       } else if (status === 'failed') {
         progressTracker.failed++;
-        logger.warn(`批次 ${batchIndex + 1} 处理失败: ${error?.message || '未知错误'}`);
+        logger.warn(t(this.config, 'concurrent_group_failed', { index: batchIndex + 1, error: error?.message || String(error) }));
       }
     };
 
@@ -613,10 +717,10 @@ export class CodeReviewer {
       
       const elapsed = ((totalDurationMs) / 1000).toFixed(1);
       const totalIssues = allIssues.length;
-      logger.success(`AI分析完成，发现${totalIssues}个问题，共耗时：${elapsed}秒`);
+      logger.success(t(this.config, 'ai_analysis_done_summary', { totalIssues, elapsed }));
       
     } catch (error) {
-      logger.error(`并发处理过程中发生错误: ${error.message}`);
+      logger.error(t(this.config, 'concurrent_processing_error', { error: error?.message || String(error) }));
       throw error;
     }
   }
@@ -627,7 +731,7 @@ export class CodeReviewer {
    * @param {SmartBatching} smartBatching - 智能分批实例
    */
   async processBatchesSerially(batches, smartBatching) {
-    logger.info(`使用串行模式处理 ${batches.length} 个批次`);
+    logger.info(t(this.config, 'serial_process_batches_info', { count: batches.length }));
     const startTime = Date.now();
     
     for (let i = 0; i < batches.length; i++) {
@@ -637,21 +741,21 @@ export class CodeReviewer {
       // 判断批次类型并输出相应信息
       if (batch.isLargeFileSegment) {
         // 大文件批次 - 显示文件路径和总段数
-        logger.info(`批次 ${i + 1}/${batches.length}: 分析 ${batch.segmentedFile} 文件，共${batch.totalSegments}段`);
+        logger.info(t(this.config, 'serial_large_file_batch_info', { index: i + 1, total: batches.length, file: batch.segmentedFile, segments: batch.totalSegments }));
       } else {
         // 小文件批次 - 列出所有文件
         const fileList = batch.items.map(item => item.filePath).join(',');
-        logger.info(`批次 ${i + 1}/${batches.length}: 分析 ${fileList} 文件`);
+        logger.info(t(this.config, 'serial_small_file_batch_info', { index: i + 1, total: batches.length, files: fileList }));
       }
       
       const aiIssues = await this.aiClient.analyzeSmartBatch(formattedBatch, batch);
       this.issues.push(...aiIssues);
       
-      logger.success(`批次 ${i + 1}/${batches.length} 完成`);
+      logger.success(t(this.config, 'batch_done_success', { index: i + 1, total: batches.length }));
     }
     const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
     const totalIssues = this.issues.length;
-    logger.success(`AI分析完成，发现${totalIssues}个问题，共耗时：${elapsed}秒`);
+    logger.success(t(this.config, 'ai_analysis_done_summary', { totalIssues, elapsed }));
   }
 
   async getFileContent(filePath) {
@@ -670,7 +774,7 @@ export class CodeReviewer {
         return await this.readFileStream(filePath);
       }
     } catch (error) {
-      logger.error(`❌ 读取文件内容失败 ${filePath}:`, error);
+      logger.error(t(this.config, 'read_file_failed', { file: filePath, error: error?.message || String(error) }));
       return null;
     }
   }
@@ -692,7 +796,7 @@ export class CodeReviewer {
       }
       
       // 对于大文件，使用流式读取
-      logger.debug(`使用流式读取大文件: ${filePath} (${fileSizeKB.toFixed(1)}KB)`);
+      logger.debug(t(this.config, 'stream_read_large_file_dbg', { file: filePath, sizeKB: fileSizeKB.toFixed(1) }));
       
       const chunks = [];
       const stream = fs.createReadStream(filePath, { encoding: 'utf8' });
@@ -720,8 +824,10 @@ export class CodeReviewer {
     let skippedByDirectives = 0;
     for (const rule of this.rules) {
       try {
-        // 可选：当文件中存在指定清理/反证模式时，跳过该规则以降低误报
-        if (Array.isArray(rule.requiresAbsent) && rule.requiresAbsent.length > 0 && typeof rule.pattern !== 'function') {
+        // 保留通用 requiresAbsent 跳过，但当 requiresAbsent 明显是“函数调用样式”时，改为逐匹配的配对校验
+        const requiresAbsent = Array.isArray(rule.requiresAbsent) ? rule.requiresAbsent : null;
+        const isPairable = !!(requiresAbsent && requiresAbsent.some(s => /\(/.test(String(s))));
+        if (!isPairable && requiresAbsent && requiresAbsent.length > 0 && typeof rule.pattern !== 'function') {
           const hasCleanup = rule.requiresAbsent.some(rxStr => {
             try {
               const rx = this.getCachedRegex(rxStr, rule.flags || 'gm');
@@ -730,7 +836,7 @@ export class CodeReviewer {
               return false;
             }
           });
-          if (hasCleanup) continue; // 文件已存在对应清理逻辑，跳过此规则
+          if (hasCleanup) continue;
         }
 
         // 简化：pattern 支持函数。若返回片段字符串或字符串数组，则直接使用该片段作为结果；
@@ -772,6 +878,44 @@ export class CodeReviewer {
         // 记录该规则已在哪些代码片段上报过，避免重复片段
         const reportedSnippets = new Set();
 
+        const escapeRegExp = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const findAssignedHandleBefore = (src, mIndex) => {
+          const lineStart = src.lastIndexOf('\n', Math.max(0, mIndex - 1)) + 1;
+          const left = src.slice(lineStart, mIndex);
+          // 通用赋值检测：匹配“标识符或属性” + “= 或 :=”结尾（覆盖多语言常见语法）
+          const assignMatch = /([A-Za-z_][\w$]*(?:\.[A-Za-z_][\w$]*)*)\s*(?:=|:=)\s*$/.exec(left);
+          if (assignMatch) return assignMatch[1];
+          return null;
+        };
+        const isEffectiveIndex = (idx) => {
+          if (this.isIndexInRanges(idx, commentRanges)) return false;
+          if (this.isIndexInRanges(idx, disable.suppressRanges || [])) return false;
+          return true;
+        };
+        const buildPairedCleanupRegexes = (rxStr, handle, flags) => {
+          const raw = String(rxStr);
+          // 仅当 requiresAbsent 为“函数调用样式”时构建带句柄的清理匹配
+          if (!/(\(|\\\()/.test(raw)) return [];
+          const escapedHandle = escapeRegExp(handle);
+          const fFlags = flags || 'gm';
+          const out = [];
+          // 1) 函数调用样式：fnName( handle )
+          try {
+            const withHandle = raw.replace(/\\\(/, `\\(\\s*${escapedHandle}\\s*`);
+            const patternStr = withHandle.endsWith(')') || /\\\)\s*$/.test(withHandle) ? withHandle : `${withHandle}\\)`;
+            out.push(new RegExp(patternStr, fFlags));
+          } catch (_) {}
+          // 2) 句柄方法样式：handle.fnName( ... )
+          try {
+            const fnMatch = raw.match(/([A-Za-z_][A-Za-z0-9_.$]*)\s*(?:\\\(|\()/);
+            if (fnMatch) {
+              const fn = escapeRegExp(fnMatch[1]);
+              out.push(new RegExp(`${escapedHandle}\\s*\\.\\s*${fn}\\s*\\(`, fFlags));
+            }
+          } catch (_) {}
+          return out;
+        };
+
         while ((match = regex.exec(content)) !== null) {
           // 若匹配位置在注释中，跳过
           if (this.isIndexInRanges(match.index, commentRanges)) {
@@ -783,6 +927,32 @@ export class CodeReviewer {
             skippedByDirectives++;
             continue;
           }
+          // 当规则的 requiresAbsent 为“函数调用样式”时：逐匹配校验是否存在针对同一句柄的清理
+          if (isPairable && requiresAbsent && requiresAbsent.length > 0) {
+            const handle = findAssignedHandleBefore(content, match.index);
+            let cleaned = false;
+            if (handle) {
+              for (const rxStr of requiresAbsent) {
+                const pairedRegexes = buildPairedCleanupRegexes(rxStr, handle, rule.flags);
+                if (!pairedRegexes || pairedRegexes.length === 0) continue;
+                for (const pairedRx of pairedRegexes) {
+                  let cm;
+                  while ((cm = pairedRx.exec(content)) !== null) {
+                    if (isEffectiveIndex(cm.index)) { cleaned = true; break; }
+                  }
+                  if (cleaned) break;
+                }
+                if (cleaned) break;
+              }
+            } else {
+              // 未保存返回句柄则视为未清理风险（无法对应清理目标）
+              cleaned = false;
+            }
+            if (cleaned) {
+              continue; // 已对同一句柄执行清理，不报警
+            }
+          }
+
           const lineNumber = this.getLineNumber(content, match.index);
           const snippetText = (match[0] || '').substring(0, BATCH_CONSTANTS.MAX_SNIPPET_LENGTH);
 
@@ -804,15 +974,15 @@ export class CodeReviewer {
           });
         }
       } catch (error) {
-        logger.warn(`规则 ${rule.id} 执行失败:`, error.message);
+        logger.warn(t(this.config, 'rule_exec_failed_warn', { id: rule.id, error: error?.message || String(error) }));
       }
     }
 
     if (skippedByComments > 0) {
-      logger.debug(`注释代码已跳过审查（${skippedByComments}条匹配）`);
+      logger.debug(t(this.config, 'skip_by_comments_dbg', { count: skippedByComments }));
     }
     if (skippedByDirectives > 0) {
-      logger.debug(`指令禁用范围已跳过审查（${skippedByDirectives}条匹配）`);
+      logger.debug(t(this.config, 'skip_by_directives_dbg', { count: skippedByDirectives }));
     }
 
     return issues;
@@ -876,7 +1046,7 @@ export class CodeReviewer {
     if (!shouldInclude) {
       return {
         reviewable: false,
-        reason: `文件扩展名 ${ext} 不在支持列表中`,
+        reason: t(this.config, 'file_ext_not_supported_reason', { ext }),
         matchedPattern: null
       };
     }
@@ -897,7 +1067,7 @@ export class CodeReviewer {
       if (originalPattern === normalized || originalPattern === relativePath || originalPattern === basename) {
         return {
           reviewable: false,
-          reason: '匹配精确模式',
+          reason: t(this.config, 'file_reason_exact_match'),
           matchedPattern: originalPattern
         };
       }
@@ -911,7 +1081,7 @@ export class CodeReviewer {
           if (normalizedMatch || relativeMatch) {
             return {
               reviewable: false,
-              reason: '匹配正则表达式',
+              reason: t(this.config, 'file_reason_regex_match'),
               matchedPattern: originalPattern
             };
           }
@@ -925,7 +1095,7 @@ export class CodeReviewer {
         if (this.matchPattern(normalized, patternStr) || this.matchPattern(relativePath, patternStr)) {
           return {
             reviewable: false,
-            reason: '匹配glob模式',
+            reason: t(this.config, 'file_reason_glob_match'),
             matchedPattern: originalPattern
           };
         }
@@ -1014,7 +1184,7 @@ export class CodeReviewer {
     
     // 检查文件大小限制
     if (content.length > (this.config.ai?.maxFileSizeKB || DEFAULT_CONFIG.MAX_FILE_SIZE_KB) * 1024) {
-      logger.info(`跳过AI分析大文件: ${filePath}`);
+      logger.info(t(this.config, 'skip_ai_large_file', { file: filePath }));
       return false;
     }