autosnippet 3.0.11 → 3.1.0

package/lib/service/guard/GuardCrossFileChecks.js

@@ -0,0 +1,326 @@
+/**
+ * GuardCrossFileChecks - Guard 跨文件检查
+ *
+ * 从 GuardCheckEngine._runCrossFileChecks 拆分
+ * 包含: 跨文件规则检查 + 路径归一化工具
+ */
+
+/**
+ * 解析相对 import 路径为归一化路径（去掉扩展名）
+ * @param {string} fromDir - 当前文件目录
+ * @param {string} importPath - 相对路径如 './foo' 或 '../bar/baz'
+ * @returns {string|null}
+ */
+export function resolveImportPath(fromDir, importPath) {
+  try {
+    const parts = `${fromDir}/${importPath}`.split('/');
+    const resolved = [];
+    for (const p of parts) {
+      if (p === '.' || p === '') {
+        continue;
+      }
+      if (p === '..') {
+        resolved.pop();
+        continue;
+      }
+      resolved.push(p);
+    }
+    // 去掉扩展名归一化
+    let result = resolved.join('/');
+    result = result.replace(/\.(js|ts|jsx|tsx|mjs|mts)$/, '');
+    // 移除 /index 后缀（index barrel 导入）
+    result = result.replace(/\/index$/, '');
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 归一化文件路径（去扩展名，用于 import 比较）
+ * @param {string} filePath
+ * @returns {string}
+ */
+export function normalizeFilePath(filePath) {
+  return filePath.replace(/\.(js|ts|jsx|tsx|mjs|mts)$/, '').replace(/\/index$/, '');
+}
+
+/**
+ * 跨文件检查 — 需要多文件上下文才能发现的问题
+ * @param {Array<{path: string, content: string}>} files
+ * @param {object} options
+ * @param {string[]} [options.disabledRules] - 禁用的规则 ID 列表
+ * @returns {Array<{ruleId, message, severity, locations}>}
+ */
+export function runCrossFileChecks(files, options = {}) {
+  const violations = [];
+  const disabledSet = new Set(options.disabledRules || []);
+  const isDisabled = (ruleId) => disabledSet.has(ruleId);
+
+  // ── ObjC Category 跨文件重名检查 ──
+  if (!isDisabled('objc-cross-file-duplicate-category')) {
+    const categoryMap = new Map();
+    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),
+          });
+        }
+      }
+    }
+
+    for (const [key, locations] of categoryMap) {
+      if (locations.length <= 1) {
+        continue;
+      }
+
+      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;
+      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,
+        });
+      }
+    }
+  } // end isDisabled('objc-cross-file-duplicate-category')
+
+  // ── JS/TS 循环依赖检查 ──
+  // 检测 A imports B 且 B imports A 的直接循环
+  if (!isDisabled('js-circular-import')) {
+    const jsImportMap = new Map(); // filePath → Set<importedPath>
+    const jsExts = new Set(['js', 'ts', 'jsx', 'tsx', 'mjs', 'mts']);
+    const importRegex =
+      /(?:import\s+.+?\s+from\s+['"](.+?)['"]|require\s*\(\s*['"](.+?)['"]\s*\))/g;
+
+    for (const { path: filePath, content } of files) {
+      const ext = filePath.split('.').pop()?.toLowerCase();
+      if (!jsExts.has(ext)) {
+        continue;
+      }
+
+      const imports = new Set();
+      const lines = content.split(/\r?\n/);
+      for (const line of lines) {
+        importRegex.lastIndex = 0;
+        let m;
+        while ((m = importRegex.exec(line)) !== null) {
+          const importPath = m[1] || m[2];
+          if (importPath.startsWith('.')) {
+            // 解析相对路径为归一化 key
+            const dir = filePath.substring(0, filePath.lastIndexOf('/'));
+            const resolved = resolveImportPath(dir, importPath);
+            if (resolved) {
+              imports.add(resolved);
+            }
+          }
+        }
+      }
+      if (imports.size > 0) {
+        jsImportMap.set(normalizeFilePath(filePath), imports);
+      }
+    }
+
+    // 检测直接双向循环: A→B 且 B→A
+    const reportedCycles = new Set();
+    for (const [fileA, importsA] of jsImportMap) {
+      for (const depB of importsA) {
+        const importsB = jsImportMap.get(depB);
+        if (importsB?.has(fileA)) {
+          const cycleKey = [fileA, depB].sort().join(' <-> ');
+          if (!reportedCycles.has(cycleKey)) {
+            reportedCycles.add(cycleKey);
+            violations.push({
+              ruleId: 'js-circular-import',
+              message: `检测到循环依赖，两个模块互相导入可能导致运行时 undefined`,
+              severity: 'warning',
+              locations: [
+                { filePath: fileA, line: 1, snippet: `imports ${depB.split('/').pop()}` },
+                { filePath: depB, line: 1, snippet: `imports ${fileA.split('/').pop()}` },
+              ],
+            });
+          }
+        }
+      }
+    }
+  } // end isDisabled('js-circular-import')
+
+  // ── Java/Kotlin 同名类跨文件检查 ──
+  if (!isDisabled('java-duplicate-class-name')) {
+    const classMap = new Map(); // className → [{filePath, line, snippet}]
+    const javaClassRegex = /(?:public\s+)?(?:abstract\s+)?(?:final\s+)?class\s+(\w+)/;
+    const jkExts = new Set(['java', 'kt']);
+
+    for (const { path: filePath, content } of files) {
+      const ext = filePath.split('.').pop()?.toLowerCase();
+      if (!jkExts.has(ext)) {
+        continue;
+      }
+
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        const m = javaClassRegex.exec(lines[i]);
+        if (m) {
+          const className = m[1];
+          if (!classMap.has(className)) {
+            classMap.set(className, []);
+          }
+          classMap.get(className).push({
+            filePath,
+            line: i + 1,
+            snippet: lines[i].trim().slice(0, 120),
+          });
+        }
+      }
+    }
+
+    for (const [className, locations] of classMap) {
+      if (locations.length > 1) {
+        violations.push({
+          ruleId: 'java-duplicate-class-name',
+          message: `类名 "${className}" 在 ${locations.length} 个文件中定义，可能导致导入歧义`,
+          severity: 'info',
+          locations,
+        });
+      }
+    }
+  } // end isDisabled('java-duplicate-class-name')
+
+  // ── Go 多文件 init() 函数检查 ──
+  // 同一 package 下多个文件都有 init()，执行顺序依赖文件名排序，容易出错
+  if (!isDisabled('go-multiple-init')) {
+    const goInitMap = new Map(); // dirPath → [{filePath, line}]
+
+    for (const { path: filePath, content } of files) {
+      if (!filePath.endsWith('.go')) {
+        continue;
+      }
+
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        if (/^func\s+init\s*\(\s*\)/.test(lines[i].trim())) {
+          const dir = filePath.substring(0, filePath.lastIndexOf('/'));
+          if (!goInitMap.has(dir)) {
+            goInitMap.set(dir, []);
+          }
+          goInitMap.get(dir).push({
+            filePath,
+            line: i + 1,
+            snippet: lines[i].trim().slice(0, 120),
+          });
+          break; // 每个文件只记录一次
+        }
+      }
+    }
+
+    for (const [dir, locations] of goInitMap) {
+      if (locations.length > 2) {
+        violations.push({
+          ruleId: 'go-multiple-init',
+          message: `同一 package (${dir.split('/').pop()}) 中 ${locations.length} 个文件都定义了 init()，执行顺序依赖文件名排序`,
+          severity: 'info',
+          locations,
+        });
+      }
+    }
+  } // end isDisabled('go-multiple-init')
+
+  // ── Swift Extension 方法跨文件冲突检查 ──
+  if (!isDisabled('swift-cross-file-extension-conflict')) {
+    const swiftExtMethodMap = new Map(); // "TypeName.methodName" → [{filePath, line}]
+    const swiftExtRegex = /extension\s+(\w+)/;
+    const swiftFuncRegex = /func\s+(\w+)\s*\(/;
+
+    for (const { path: filePath, content } of files) {
+      if (!filePath.endsWith('.swift')) {
+        continue;
+      }
+
+      const lines = content.split(/\r?\n/);
+      let currentExt = null;
+      let braceDepth = 0;
+
+      for (let i = 0; i < lines.length; i++) {
+        const extMatch = swiftExtRegex.exec(lines[i]);
+        if (extMatch && !currentExt) {
+          currentExt = extMatch[1];
+          braceDepth = 0;
+        }
+
+        if (currentExt) {
+          for (const ch of lines[i]) {
+            if (ch === '{') {
+              braceDepth++;
+            } else if (ch === '}') {
+              braceDepth--;
+            }
+          }
+
+          const funcMatch = swiftFuncRegex.exec(lines[i]);
+          if (funcMatch && braceDepth >= 1) {
+            const key = `${currentExt}.${funcMatch[1]}`;
+            if (!swiftExtMethodMap.has(key)) {
+              swiftExtMethodMap.set(key, []);
+            }
+            swiftExtMethodMap.get(key).push({
+              filePath,
+              line: i + 1,
+              snippet: lines[i].trim().slice(0, 120),
+            });
+          }
+
+          if (braceDepth <= 0) {
+            currentExt = null;
+          }
+        }
+      }
+    }
+
+    for (const [key, locations] of swiftExtMethodMap) {
+      if (locations.length > 1) {
+        const uniqueFiles = new Set(locations.map((l) => l.filePath));
+        if (uniqueFiles.size > 1) {
+          violations.push({
+            ruleId: 'swift-cross-file-extension-conflict',
+            message: `Extension 方法 ${key} 在 ${uniqueFiles.size} 个文件中定义，可能导致方法冲突`,
+            severity: 'warning',
+            locations,
+          });
+        }
+      }
+    }
+  } // end isDisabled('swift-cross-file-extension-conflict')
+
+  return violations;
+}

package/lib/service/guard/GuardPatternUtils.js

@@ -0,0 +1,187 @@
+/**
+ * GuardPatternUtils - Guard 模式匹配与掩码工具函数
+ *
+ * 从 GuardCheckEngine 拆分，包含:
+ * - compilePattern: 正则编译（带缓存）
+ * - clearPatternCache: 清除正则缓存
+ * - buildTestBlockMask: 测试块掩码（Rust #[cfg(test)]）
+ * - buildCommentMask: 注释行掩码
+ * - detectLanguage: 文件扩展名推断语言
+ */
+
+import { LanguageService } from '../../shared/LanguageService.js';
+
+/** @type {Map<string, RegExp>} 已编译的正则缓存 (pattern string → RegExp) */
+const _regexCache = new Map();
+
+/**
+ * 编译正则模式（支持 RegExp 对象和 string，带缓存）
+ * @param {RegExp|string} pattern
+ * @returns {RegExp}
+ */
+export function compilePattern(pattern) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  const key = String(pattern);
+  let cached = _regexCache.get(key);
+  if (!cached) {
+    cached = new RegExp(key);
+    _regexCache.set(key, cached);
+  }
+  return cached;
+}
+
+/**
+ * 清除正则缓存
+ */
+export function clearPatternCache() {
+  _regexCache.clear();
+}
+
+/**
+ * 构建内联测试块掩码
+ * 目前支持 Rust #[cfg(test)] mod xxx { ... } 块
+ * @param {string[]} lines
+ * @param {string} language
+ * @returns {boolean[]} 每行是否在测试块内
+ */
+export function 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;
+        }
+        // 单行 #[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[]} 每行是否为注释行
+ */
+export function 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;
+    }
+  }
+
+  return mask;
+}
+
+/**
+ * 从文件扩展名推断语言
+ */
+export function detectLanguage(filePath) {
+  if (!filePath) {
+    return 'unknown';
+  }
+  const lang = LanguageService.inferLang(filePath);
+  // 向后兼容: Guard 内置规则使用 'objc' 而非 'objectivec'
+  return LanguageService.toGuardLangId(lang);
+}

package/lib/service/guard/GuardService.js

@@ -12,12 +12,18 @@ import { unixNow } from '../../shared/utils/common.js';
 export class GuardService {
   /**
    * @param {import('../../domain/knowledge/KnowledgeRepository.js').KnowledgeRepository} knowledgeRepository
+   * @param {object} auditLogger
+   * @param {object} gateway
+   * @param {object} [deps] - 可选依赖注入
+   * @param {import('./GuardCheckEngine.js').GuardCheckEngine} [deps.guardCheckEngine] - 核心引擎实例
    */
-  constructor(knowledgeRepository, auditLogger, gateway) {
+  constructor(knowledgeRepository, auditLogger, gateway, deps = {}) {
     this.knowledgeRepository = knowledgeRepository;
     this.auditLogger = auditLogger;
     this.gateway = gateway;
     this.logger = Logger.getInstance();
+    /** @type {import('./GuardCheckEngine.js').GuardCheckEngine|null} */
+    this._engine = deps.guardCheckEngine || null;
   }
 
   /**
@@ -152,7 +158,8 @@ export class GuardService {
 
   /**
    * 检查代码是否匹配 Guard 规则
-   * 查询所有 active 的 rule 实体的 constraints.guards[]
+   * 优先代理到 GuardCheckEngine（完整管线: 内置 + DB + EP + Code-Level + AST），
+   * 若引擎不可用则降级为仅 DB 规则的简化检查
    */
   async checkCode(code, options = {}) {
     try {
@@ -162,51 +169,86 @@ export class GuardService {
 
       const { language = null } = options;
 
-      // V3: 使用 findActiveRules() 查询 kind='rule' + lifecycle='active'
-      let guardEntries = await this.knowledgeRepository.findActiveRules();
-
-      // 按语言过滤
-      if (language) {
-        guardEntries = guardEntries.filter((e) => !e.language || e.language === language);
-      }
-
-      const matches = [];
-      for (const entry of guardEntries) {
-        const guards = entry.constraints?.guards || [];
-        for (const guard of guards) {
-          try {
-            const regex = new RegExp(guard.pattern, 'gm');
-            const codeMatches = [...code.matchAll(regex)];
-            if (codeMatches.length > 0) {
-              matches.push({
-                ruleId: entry.id,
-                ruleName: entry.title,
-                severity: guard.severity || 'warning',
-                message: guard.message || '',
-                matches: codeMatches.map((m) => ({
-                  match: m[0],
-                  index: m.index,
-                  line: code.substring(0, m.index).split('\\n').length,
-                })),
-                matchCount: codeMatches.length,
-              });
-            }
-          } catch (e) {
-            this.logger.warn('Error matching guard pattern', {
-              entryId: entry.id,
-              error: e.message,
-            });
-          }
+      // ── 优先路径: 代理到 GuardCheckEngine（完整管线）──
+      if (this._engine) {
+        try {
+          const violations = this._engine.checkCode(code, language || 'unknown', {
+            scope: 'file',
+          });
+          return violations.map((v) => ({
+            ruleId: v.ruleId,
+            ruleName: v.ruleId,
+            severity: v.severity || 'warning',
+            message: v.message || '',
+            line: v.line,
+            snippet: v.snippet,
+            matchCount: 1,
+            ...(v.fixSuggestion ? { fixSuggestion: v.fixSuggestion } : {}),
+            ...(v.reasoning ? { reasoning: v.reasoning } : {}),
+          }));
+        } catch (engineErr) {
+          this.logger.debug('GuardCheckEngine.checkCode failed, falling back to DB-only check', {
+            error: engineErr.message,
+          });
         }
       }
 
-      return matches;
+      // ── 降级路径: 仅 DB 规则简化检查 ──
+      return this._checkCodeDbOnly(code, { language });
     } catch (error) {
       this.logger.error('Error checking code against rules', { error: error.message });
       throw error;
     }
   }
 
+  /**
+   * 仅 DB 规则的简化检查（降级路径）
+   * @private
+   */
+  async _checkCodeDbOnly(code, options = {}) {
+    const { language = null } = options;
+
+    // V3: 使用 findActiveRules() 查询 kind='rule' + lifecycle='active'
+    let guardEntries = await this.knowledgeRepository.findActiveRules();
+
+    // 按语言过滤
+    if (language) {
+      guardEntries = guardEntries.filter((e) => !e.language || e.language === language);
+    }
+
+    const matches = [];
+    for (const entry of guardEntries) {
+      const guards = entry.constraints?.guards || [];
+      for (const guard of guards) {
+        try {
+          const regex = new RegExp(guard.pattern, 'gm');
+          const codeMatches = [...code.matchAll(regex)];
+          if (codeMatches.length > 0) {
+            matches.push({
+              ruleId: entry.id,
+              ruleName: entry.title,
+              severity: guard.severity || 'warning',
+              message: guard.message || '',
+              matches: codeMatches.map((m) => ({
+                match: m[0],
+                index: m.index,
+                line: code.substring(0, m.index).split('\\n').length,
+              })),
+              matchCount: codeMatches.length,
+            });
+          }
+        } catch (e) {
+          this.logger.warn('Error matching guard pattern', {
+            entryId: entry.id,
+            error: e.message,
+          });
+        }
+      }
+    }
+
+    return matches;
+  }
+
   /**
    * 查询规则列表 (kind='rule' + knowledgeType='boundary-constraint')
    */