autosnippet 3.0.11 → 3.0.13

package/lib/service/guard/GuardCheckEngine.js

@@ -8,6 +8,9 @@
 import * as AstAnalyzerModule from '../../core/AstAnalyzer.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { LanguageService } from '../../shared/LanguageService.js';
+import { compilePattern, clearPatternCache, buildTestBlockMask, buildCommentMask, detectLanguage } from './GuardPatternUtils.js';
+import { runCodeLevelChecks } from './GuardCodeChecks.js';
+import { runCrossFileChecks } from './GuardCrossFileChecks.js';
 
 /**
  * 内置默认规则集 — 多语言基础规则
@@ -454,17 +457,8 @@ const BUILT_IN_RULES = {
 
 };
 
-/**
- * 从文件扩展名推断语言
- */
-export function detectLanguage(filePath) {
-  if (!filePath) {
-    return 'unknown';
-  }
-  const lang = LanguageService.inferLang(filePath);
-  // 向后兼容: objectivec → objc
-  return lang === 'objectivec' ? 'objc' : lang;
-}
+// 向后兼容: 从 GuardPatternUtils 重新导出 detectLanguage
+export { detectLanguage } from './GuardPatternUtils.js';
 
 /**
  * GuardCheckEngine - 核心检查引擎
@@ -480,8 +474,13 @@ export class GuardCheckEngine {
     this._cacheTTL = options.cacheTTL || 60_000; // 1min
     /** @type {Map<string, object>} Enhancement Pack 注入的外部规则 */
     this._externalRules = new Map();
-    /** @type {Map<string, RegExp>} 已编译的正则缓存 (pattern string → RegExp) */
-    this._regexCache = new Map();
+    /** @type {boolean} EP 规则是否已注入（幂等标记，避免每次请求重复注入） */
+    this._epInjected = false;
+    /**
+     * Guard 配置 — 允许禁用特定规则或调整 Code-Level 检查阈值
+     * @type {{ disabledRules?: string[], codeLevelThresholds?: Record<string, number> }}
+     */
+    this._guardConfig = options.guardConfig || {};
   }
 
   /**
@@ -493,6 +492,8 @@ export class GuardCheckEngine {
     if (!Array.isArray(rules)) return;
     for (const rule of rules) {
       if (!rule.ruleId) continue;
+      // 已注入的 ruleId 跳过（幂等）
+      if (this._externalRules.has(rule.ruleId)) continue;
       // 跳过与 BUILT_IN_RULES 重复的模式（通过比较 pattern 源文本）
       const rulePatternStr = rule.pattern instanceof RegExp ? rule.pattern.source : String(rule.pattern || '');
       const isDuplicate = Object.entries(this._builtInRules).some(([, builtIn]) => {
@@ -519,6 +520,12 @@ export class GuardCheckEngine {
     this.logger.debug(`[GuardCheckEngine] External rules injected: ${this._externalRules.size} active`);
   }
 
+  /**
+   * EP 注入幂等标记 — 调用者可用此判断是否已完成注入，避免重复加载 EnhancementRegistry
+   */
+  isEpInjected() { return this._epInjected; }
+  markEpInjected() { this._epInjected = true; }
+
   /**
    * 获取所有启用的规则 (数据库 + 内置)
    */
@@ -622,6 +629,13 @@ export class GuardCheckEngine {
       rules = rules.filter((r) => !r.languages?.length || r.languages.includes(language));
     }
 
+    // 按 disabledRules 配置过滤
+    const disabledRules = this._guardConfig.disabledRules;
+    if (Array.isArray(disabledRules) && disabledRules.length > 0) {
+      const disabledSet = new Set(disabledRules);
+      rules = rules.filter((r) => !disabledSet.has(r.id || r.name));
+    }
+
     // 合并 AST 规则（供外部调用者使用，如 GuardFeedbackLoop.查找 fixSuggestion）
     if (this._astRulesCache?.length) {
       let astRules = this._astRulesCache;
@@ -673,11 +687,11 @@ export class GuardCheckEngine {
 
     // 预计算注释行掩码 — 供 skipComments 规则使用
     // 识别: // 行注释, /// doc, //! inner doc, /* block */, # Python/Shell 行注释
-    const commentLines = this._buildCommentMask(lines, language);
+    const commentLines = buildCommentMask(lines, language);
 
     // 预计算测试块掩码 — 供 skipTestBlocks 规则使用
     // Rust: #[cfg(test)] mod tests { ... } 内联测试模块
-    const testBlockLines = this._buildTestBlockMask(lines, language);
+    const testBlockLines = buildTestBlockMask(lines, language);
 
     for (const rule of rules) {
       // 跳过空模式或特殊标记 (?!) — 由 code-level 检查接管
@@ -687,7 +701,7 @@ export class GuardCheckEngine {
 
       let re;
       try {
-        re = this._compilePattern(rule.pattern);
+        re = compilePattern(rule.pattern);
       } catch {
         this.logger.debug(`Invalid regex in rule ${rule.id}: ${rule.pattern}`);
         continue;
@@ -721,7 +735,10 @@ export class GuardCheckEngine {
     }
 
     // Code-level 检查（不依赖正则）
-    violations.push(...this._runCodeLevelChecks(code, language, lines));
+    violations.push(...runCodeLevelChecks(code, language, lines, {
+      disabledRules: this._guardConfig.disabledRules,
+      codeLevelThresholds: this._guardConfig.codeLevelThresholds,
+    }));
 
     // AST 语义规则检查
     violations.push(...this._runAstRuleChecks(code, language));
@@ -927,135 +944,6 @@ export class GuardCheckEngine {
     }
   }
 
-  /**
-   * 代码级别检查 - 需要上下文理解的检查（跨行 / 配对检查）
-   * 按语言分发到各自的检查逻辑
-   */
-  _runCodeLevelChecks(code, language, lines) {
-    const violations = [];
-
-    // ── ObjC ──
-    if (language === 'objc') {
-      // KVO 观察者未移除检查
-      if (code.includes('addObserver') && !code.includes('removeObserver')) {
-        const lineIdx = lines.findIndex((l) => /addObserver/.test(l));
-        violations.push({
-          ruleId: 'objc-kvo-missing-remove',
-          message: '存在 addObserver 未发现配对 removeObserver，请在 dealloc 或合适时机移除',
-          severity: 'warning',
-          line: lineIdx >= 0 ? lineIdx + 1 : 1,
-          snippet: lineIdx >= 0 ? lines[lineIdx].trim().slice(0, 120) : '',
-          dimension: 'file',
-        });
-      }
-
-      // ObjC Category 重名检查 (同文件)
-      const categoryRegex = /@interface\s+(\w+)\s*\(\s*(\w+)\s*\)/g;
-      const categories = {};
-      for (let i = 0; i < lines.length; i++) {
-        categoryRegex.lastIndex = 0;
-        const m = categoryRegex.exec(lines[i]);
-        if (!m) {
-          continue;
-        }
-        const key = `${m[1]}(${m[2]})`;
-        if (!categories[key]) {
-          categories[key] = [];
-        }
-        categories[key].push({ line: i + 1, snippet: lines[i].trim().slice(0, 120) });
-      }
-      for (const [key, occs] of Object.entries(categories)) {
-        if (occs.length <= 1) {
-          continue;
-        }
-        for (let j = 1; j < occs.length; j++) {
-          violations.push({
-            ruleId: 'objc-duplicate-category',
-            message: `同文件内 Category 重名：${key}，首次在第 ${occs[0].line} 行`,
-            severity: 'warning',
-            line: occs[j].line,
-            snippet: occs[j].snippet,
-            dimension: 'file',
-          });
-        }
-      }
-    }
-
-    // ── JavaScript / TypeScript ──
-    if (language === 'javascript' || language === 'typescript') {
-      // Promise 未处理 rejection 检查
-      // 文件中存在 .then() 但没有对应的 .catch() 或 try-catch
-      if (code.includes('.then(') && !code.includes('.catch(') && !code.includes('try')) {
-        const thenLines = [];
-        for (let i = 0; i < lines.length; i++) {
-          if (/\.then\s*\(/.test(lines[i])) {
-            thenLines.push(i);
-          }
-        }
-        if (thenLines.length > 0) {
-          violations.push({
-            ruleId: 'js-unhandled-promise',
-            message: 'Promise 链缺少 .catch() 错误处理，未捕获的 rejection 可能导致静默失败',
-            severity: 'warning',
-            line: thenLines[0] + 1,
-            snippet: lines[thenLines[0]].trim().slice(0, 120),
-            dimension: 'file',
-          });
-        }
-      }
-    }
-
-    // ── Go ──
-    if (language === 'go') {
-      // defer 在循环内检查 — defer 在函数结束时才执行，循环内 defer 可能资源泄露
-      let inLoop = false;
-      for (let i = 0; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
-        if (/^for\s/.test(trimmed) || /^for\s*\{/.test(trimmed)) {
-          inLoop = true;
-        }
-        if (inLoop && /^\s*defer\s/.test(lines[i])) {
-          violations.push({
-            ruleId: 'go-defer-in-loop',
-            message: 'defer 在循环内会延迟到函数返回时才执行，可能导致资源泄露或大量堆积',
-            severity: 'warning',
-            line: i + 1,
-            snippet: lines[i].trim().slice(0, 120),
-            dimension: 'file',
-            fixSuggestion: '将循环体提取到独立函数中，或手动调用 Close()',
-          });
-        }
-        // 简化: 遇到 } 且缩进回到顶层，认为循环结束
-        if (inLoop && trimmed === '}' && (lines[i].match(/^\t/) || lines[i].match(/^}/))) {
-          inLoop = false;
-        }
-      }
-    }
-
-    // ── Python ──
-    if (language === 'python') {
-      // 文件中同时存在 tab 和 space 缩进
-      let hasTab = false;
-      let hasSpace = false;
-      for (let i = 0; i < Math.min(lines.length, 200); i++) {
-        if (/^\t/.test(lines[i])) hasTab = true;
-        if (/^ {2,}/.test(lines[i]) && !/^\t/.test(lines[i])) hasSpace = true;
-      }
-      if (hasTab && hasSpace) {
-        violations.push({
-          ruleId: 'py-mixed-indentation',
-          message: '文件混用 tab 和 space 缩进，Python 对此敏感，请统一使用 space',
-          severity: 'warning',
-          line: 1,
-          snippet: '',
-          dimension: 'file',
-        });
-      }
-    }
-
-    return violations;
-  }
-
   /**
    * 文件审计 - 读取文件并检查
    * @param {string} filePath - 绝对路径
@@ -1096,7 +984,9 @@ export class GuardCheckEngine {
     }
 
     // ── 跨文件检查 ──
-    const crossFileViolations = this._runCrossFileChecks(files);
+    const crossFileViolations = runCrossFileChecks(files, {
+      disabledRules: this._guardConfig.disabledRules,
+    });
     totalViolations += crossFileViolations.length;
     totalErrors += crossFileViolations.filter((v) => v.severity === 'error').length;
 
@@ -1112,235 +1002,13 @@ export class GuardCheckEngine {
     };
   }
 
-  /**
-   * 跨文件检查 — 需要多文件上下文才能发现的问题
-   * @param {Array<{path: string, content: string}>} files
-   * @returns {Array<{ruleId, message, severity, locations}>}
-   */
-  _runCrossFileChecks(files) {
-    const violations = [];
-
-    // ── ObjC Category 跨文件重名检查 ──
-    // 收集所有文件中的 @interface ClassName(CategoryName) 声明
-    const categoryMap = new Map(); // key: "ClassName(CategoryName)" → [{filePath, line, snippet}]
-    const categoryRegex = /@interface\s+(\w+)\s*\(\s*(\w+)\s*\)/g;
-
-    for (const { path: filePath, content } of files) {
-      const ext = filePath.split('.').pop()?.toLowerCase();
-      if (ext !== 'm' && ext !== 'mm' && ext !== 'h') {
-        continue;
-      }
-
-      const lines = content.split(/\r?\n/);
-      for (let i = 0; i < lines.length; i++) {
-        categoryRegex.lastIndex = 0;
-        let m;
-        while ((m = categoryRegex.exec(lines[i])) !== null) {
-          const key = `${m[1]}(${m[2]})`;
-          if (!categoryMap.has(key)) {
-            categoryMap.set(key, []);
-          }
-          categoryMap.get(key).push({
-            filePath,
-            line: i + 1,
-            snippet: lines[i].trim().slice(0, 120),
-          });
-        }
-      }
-    }
-
-    // .h 和 .m 成对出现是正常的（声明 + 实现），只有同类型文件重名才是问题
-    // 或者超过 2 处声明就一定有问题
-    for (const [key, locations] of categoryMap) {
-      if (locations.length <= 1) {
-        continue;
-      }
-
-      // 按文件扩展名分组: .h 和 .m/.mm 各一个是合法的
-      const hFiles = locations.filter((l) => l.filePath.endsWith('.h'));
-      const mFiles = locations.filter((l) => !l.filePath.endsWith('.h'));
-
-      // 同类型文件中有多个声明 → 重名冲突
-      const hasDuplicateH = hFiles.length > 1;
-      const hasDuplicateM = mFiles.length > 1;
-      // 超过 2 处总声明（如 3 个文件都声明了同一个 Category）→ 一定有问题
-      const tooMany = locations.length > 2;
-
-      if (hasDuplicateH || hasDuplicateM || tooMany) {
-        // 收集冲突的那些位置
-        const conflictLocations = tooMany
-          ? locations
-          : hasDuplicateH && hasDuplicateM
-            ? locations
-            : hasDuplicateH
-              ? hFiles
-              : mFiles;
-
-        violations.push({
-          ruleId: 'objc-cross-file-duplicate-category',
-          message: `Category ${key} 在 ${conflictLocations.length} 个文件中重复声明，可能导致方法覆盖或未定义行为`,
-          severity: 'warning',
-          locations: conflictLocations,
-        });
-      }
-    }
-
-    return violations;
-  }
-
   /**
    * 清除规则缓存
    */
   clearCache() {
     this._customRulesCache = null;
     this._cacheTime = 0;
-    this._regexCache.clear();
-  }
-
-  /**
-   * 编译正则模式（支持 RegExp 对象和 string，带缓存）
-   * @param {RegExp|string} pattern
-   * @returns {RegExp}
-   */
-  _compilePattern(pattern) {
-    if (pattern instanceof RegExp) {
-      return pattern;
-    }
-    const key = String(pattern);
-    let cached = this._regexCache.get(key);
-    if (!cached) {
-      cached = new RegExp(key);
-      this._regexCache.set(key, cached);
-    }
-    return cached;
-  }
-
-  /**
-   * 构建内联测试块掩码
-   * 目前支持 Rust #[cfg(test)] mod xxx { ... } 块
-   * @param {string[]} lines
-   * @param {string} language
-   * @returns {boolean[]} 每行是否在测试块内
-   */
-  _buildTestBlockMask(lines, language) {
-    const mask = new Array(lines.length).fill(false);
-
-    // 目前仅 Rust 需要 — #[cfg(test)] 内联测试模块
-    if (language !== 'rust') return mask;
-
-    let inTestBlock = false;
-    let braceDepth = 0;
-
-    for (let i = 0; i < lines.length; i++) {
-      const trimmed = lines[i].trimStart();
-
-      if (!inTestBlock) {
-        // 检测 #[cfg(test)] 属性行
-        if (/^#\[cfg\(test\)\]/.test(trimmed)) {
-          // 向后找 mod xxx { — 标记为测试块起始
-          // 可能在同一行: #[cfg(test)] mod tests {
-          // 也可能在下一行: mod tests {
-          const restOfLine = trimmed.slice('#[cfg(test)]'.length).trim();
-          if (/^mod\s+\w+/.test(restOfLine)) {
-            // 同一行有 mod 声明
-            inTestBlock = true;
-            braceDepth = 0;
-            // 计算本行的花括号
-            for (const ch of lines[i]) {
-              if (ch === '{') braceDepth++;
-              else if (ch === '}') braceDepth--;
-            }
-            mask[i] = true;
-            if (braceDepth <= 0) inTestBlock = false; // 单行 mod 声明 (mod tests;)
-            continue;
-          }
-          // 检查下一行是否是 mod xxx {
-          if (i + 1 < lines.length && /^\s*mod\s+\w+/.test(lines[i + 1])) {
-            mask[i] = true; // #[cfg(test)] 行本身也标记
-            inTestBlock = true;
-            braceDepth = 0;
-            // 下一行会在循环中处理
-            continue;
-          }
-          // 单行 #[cfg(test)] 但后面不是 mod — 不处理
-        }
-      } else {
-        // 正在测试块内 — 追踪花括号深度
-        mask[i] = true;
-        for (const ch of lines[i]) {
-          if (ch === '{') braceDepth++;
-          else if (ch === '}') braceDepth--;
-        }
-        if (braceDepth <= 0) {
-          inTestBlock = false; // 测试块结束
-        }
-      }
-    }
-
-    return mask;
-  }
-
-  /**
-   * 构建注释行掩码 — 识别行注释和块注释内部行
-   *
-   * 支持的注释形式:
-   *   // 行注释,  /// 文档注释,  //! 内部文档注释  (C/Java/JS/TS/Go/Rust/Swift/Kotlin/Dart)
-   *   # 行注释  (Python)
-   *   /* ... * / 块注释  (C/Java/JS/TS/Go/Rust/Swift/Kotlin)
-   *   \"\"\" ... \"\"\"  (Python doc-string — 简化: 整行以 \"\"\" 开头的行)
-   *
-   * @param {string[]} lines
-   * @param {string} language
-   * @returns {boolean[]} 每行是否为注释行
-   */
-  _buildCommentMask(lines, language) {
-    const mask = new Array(lines.length).fill(false);
-    let inBlock = false; // 是否在 /* ... */ 块内
-
-    const usesHash = language === 'python'; // Python 用 # 注释
-    const usesSlash = !usesHash;            // 其他语言用 //
-
-    for (let i = 0; i < lines.length; i++) {
-      const trimmed = lines[i].trimStart();
-
-      // 块注释延续
-      if (inBlock) {
-        mask[i] = true;
-        if (trimmed.includes('*/')) {
-          inBlock = false;
-        }
-        continue;
-      }
-
-      // 块注释开始（同行不闭合）
-      if (usesSlash && /^\s*\/\*/.test(lines[i])) {
-        mask[i] = true;
-        if (!trimmed.includes('*/')) {
-          inBlock = true;
-        }
-        continue;
-      }
-
-      // 行注释: // 或 /// 或 //!
-      if (usesSlash && /^\s*\/\//.test(lines[i])) {
-        mask[i] = true;
-        continue;
-      }
-
-      // Python 行注释: #
-      if (usesHash && /^\s*#/.test(lines[i])) {
-        mask[i] = true;
-        continue;
-      }
-
-      // Python docstring 行 (简化: 整行以 """ 或 ''' 开头)
-      if (usesHash && /^\s*("""|''')/.test(lines[i])) {
-        mask[i] = true;
-        continue;
-      }
-    }
-
-    return mask;
+    clearPatternCache();
   }
 
   /**