autosnippet 3.0.10 → 3.0.13

package/lib/service/guard/GuardCodeChecks.js

@@ -0,0 +1,362 @@
+/**
+ * GuardCodeChecks - Guard 代码级别检查（跨行 / 配对检查）
+ *
+ * 从 GuardCheckEngine._runCodeLevelChecks 拆分
+ * 按语言分发到各自的检查逻辑，不依赖正则规则
+ */
+
+/**
+ * 代码级别检查 - 需要上下文理解的检查（跨行 / 配对检查）
+ * 按语言分发到各自的检查逻辑
+ * 支持 disabledRules 禁用特定检查、codeLevelThresholds 调整阈值
+ *
+ * @param {string} code - 源代码
+ * @param {string} language - 语言标识
+ * @param {string[]} lines - 按行拆分的源代码
+ * @param {object} options
+ * @param {string[]} [options.disabledRules] - 禁用的规则 ID 列表
+ * @param {Record<string, number>} [options.codeLevelThresholds] - 可配置阈值
+ * @returns {Array<{ruleId, message, severity, line, snippet, dimension?, fixSuggestion?}>}
+ */
+export function runCodeLevelChecks(code, language, lines, options = {}) {
+  const violations = [];
+  const disabledSet = new Set(options.disabledRules || []);
+  const thresholds = options.codeLevelThresholds || {};
+  /** 判断 ruleId 是否被禁用 */
+  const isDisabled = (ruleId) => disabledSet.has(ruleId);
+  /** 获取可配置阈值，回退到默认值 */
+  const threshold = (ruleId, defaultVal) => thresholds[ruleId] ?? defaultVal;
+
+  // ── ObjC ──
+  if (language === 'objc') {
+    // KVO 观察者未移除检查
+    if (!isDisabled('objc-kvo-missing-remove') && 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 重名检查 (同文件)
+    if (!isDisabled('objc-duplicate-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',
+        });
+      }
+    }
+    } // end isDisabled('objc-duplicate-category')
+  }
+
+  // ── JavaScript / TypeScript ──
+  if (language === 'javascript' || language === 'typescript') {
+    // Promise 未处理 rejection 检查
+    // 文件中存在 .then() 但没有对应的 .catch() 或 try-catch
+    if (!isDisabled('js-unhandled-promise') && 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 可能资源泄露
+    if (!isDisabled('go-defer-in-loop')) {
+    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;
+      }
+    }
+    } // end isDisabled('go-defer-in-loop')
+  }
+
+  // ── Python ──
+  if (language === 'python') {
+    // 文件中同时存在 tab 和 space 缩进
+    if (!isDisabled('py-mixed-indentation')) {
+    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',
+      });
+    }
+    } // end isDisabled('py-mixed-indentation')
+  }
+
+  // ── Swift ──
+  if (language === 'swift') {
+    // 强制解包滥用检查: 连续多行使用 ! 强制解包（单行已被正则规则覆盖，这里检查文件级滥用）
+    if (!isDisabled('swift-excessive-force-unwrap')) {
+    let forceUnwrapCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      // 排除 != 和 !== 运算符, 以及注释行
+      const trimmed = lines[i].trimStart();
+      if (trimmed.startsWith('//') || trimmed.startsWith('/*')) continue;
+      // 匹配 variable! 或 expression!. 形式，但排除 !=
+      if (/\w!(?!=)[.\s,)\]]/.test(lines[i]) || /\w!$/.test(lines[i].trim())) {
+        forceUnwrapCount++;
+      }
+    }
+    if (forceUnwrapCount > threshold('swift-excessive-force-unwrap', 5)) {
+      violations.push({
+        ruleId: 'swift-excessive-force-unwrap',
+        message: `文件包含 ${forceUnwrapCount} 处强制解包 (!)，建议使用 guard let / if let 安全解包`,
+        severity: 'warning',
+        line: 1,
+        snippet: `${forceUnwrapCount} force unwraps detected`,
+        dimension: 'file',
+        fixSuggestion: '使用 guard let value = optional else { return } 替代 optional!',
+      });
+    }
+    } // end isDisabled('swift-excessive-force-unwrap')
+  }
+
+  // ── Java ──
+  if (language === 'java') {
+    // 资源泄露检查: new InputStream/Connection/Reader 未在 try-with-resources 或 finally 中关闭
+    if (!isDisabled('java-resource-leak')) {
+    const resourcePatterns = /new\s+(FileInputStream|FileOutputStream|BufferedReader|BufferedWriter|Connection|Socket|FileReader|FileWriter|Scanner)\s*\(/;
+    const hasResourceAlloc = lines.some((l) => resourcePatterns.test(l));
+    const hasTryWithResource = code.includes('try (') || code.includes('try(');
+    const hasFinallyClose = code.includes('finally') && code.includes('.close()');
+    if (hasResourceAlloc && !hasTryWithResource && !hasFinallyClose) {
+      const lineIdx = lines.findIndex((l) => resourcePatterns.test(l));
+      violations.push({
+        ruleId: 'java-resource-leak',
+        message: '资源分配后未使用 try-with-resources 或 finally/close()，可能造成资源泄露',
+        severity: 'warning',
+        line: lineIdx >= 0 ? lineIdx + 1 : 1,
+        snippet: lineIdx >= 0 ? lines[lineIdx].trim().slice(0, 120) : '',
+        dimension: 'file',
+        fixSuggestion: '使用 try (var res = new Resource()) { ... } 自动关闭资源',
+      });
+    }
+    } // end isDisabled('java-resource-leak')
+
+    // synchronized 在非 final 字段上 — 可能导致锁对象被替换
+    if (!isDisabled('java-sync-non-final')) {
+    const syncRegex = /synchronized\s*\(\s*(\w+)\s*\)/;
+    for (let i = 0; i < lines.length; i++) {
+      const m = syncRegex.exec(lines[i]);
+      if (m && m[1] !== 'this' && !m[1].endsWith('.class')) {
+        // 检查该变量是否声明为 final
+        const varName = m[1];
+        const declaredFinal = lines.some((l) => new RegExp(`final\\s+\\w+.*\\b${varName}\\b`).test(l));
+        if (!declaredFinal) {
+          violations.push({
+            ruleId: 'java-sync-non-final',
+            message: `synchronized 使用了非 final 变量 "${varName}"，锁对象可能被重新赋值`,
+            severity: 'warning',
+            line: i + 1,
+            snippet: lines[i].trim().slice(0, 120),
+            dimension: 'file',
+            fixSuggestion: `将 ${varName} 声明为 private final`,
+          });
+        }
+      }
+    }
+    } // end isDisabled('java-sync-non-final')
+  }
+
+  // ── Kotlin ──
+  if (language === 'kotlin') {
+    // GlobalScope.launch — 生命周期泄露风险
+    if (!isDisabled('kotlin-global-scope')) {
+    for (let i = 0; i < lines.length; i++) {
+      if (/GlobalScope\s*\.\s*(launch|async)/.test(lines[i])) {
+        violations.push({
+          ruleId: 'kotlin-global-scope',
+          message: 'GlobalScope.launch/async 不绑定生命周期，可能导致协程泄露',
+          severity: 'warning',
+          line: i + 1,
+          snippet: lines[i].trim().slice(0, 120),
+          dimension: 'file',
+          fixSuggestion: '使用 viewModelScope、lifecycleScope 或自定义 CoroutineScope 替代',
+        });
+      }
+    }
+    } // end isDisabled('kotlin-global-scope')
+
+    // runBlocking 在 main/UI 线程 — 可能冻结 UI
+    if (!isDisabled('kotlin-run-blocking') && code.includes('runBlocking')) {
+      const lineIdx = lines.findIndex((l) => /runBlocking\s*[({]/.test(l));
+      if (lineIdx >= 0) {
+        violations.push({
+          ruleId: 'kotlin-run-blocking',
+          message: 'runBlocking 会阻塞当前线程，避免在 Main/UI 线程中使用',
+          severity: 'warning',
+          line: lineIdx + 1,
+          snippet: lines[lineIdx].trim().slice(0, 120),
+          dimension: 'file',
+          fixSuggestion: '改用 suspend 函数 或 launch { } 非阻塞协程',
+        });
+      }
+    }
+  }
+
+  // ── Rust ──
+  if (language === 'rust') {
+    // .unwrap() 滥用检查 — 生产代码应使用 ? 或 expect()
+    if (!isDisabled('rust-excessive-unwrap')) {
+    let unwrapCount = 0;
+    const unwrapLines = [];
+    for (let i = 0; i < lines.length; i++) {
+      const trimmed = lines[i].trimStart();
+      // 跳过测试代码和注释
+      if (trimmed.startsWith('//') || trimmed.startsWith('#[test]')) continue;
+      if (/\.unwrap\(\)/.test(lines[i])) {
+        unwrapCount++;
+        if (unwrapLines.length < 3) unwrapLines.push(i);
+      }
+    }
+    if (unwrapCount > threshold('rust-excessive-unwrap', 3)) {
+      violations.push({
+        ruleId: 'rust-excessive-unwrap',
+        message: `文件包含 ${unwrapCount} 处 .unwrap()，生产代码建议使用 ? 操作符或 .expect("reason")`,
+        severity: 'warning',
+        line: unwrapLines[0] + 1,
+        snippet: lines[unwrapLines[0]].trim().slice(0, 120),
+        dimension: 'file',
+        fixSuggestion: '使用 ? 操作符向上传播错误，或 .expect("具体原因") 提供崩溃上下文',
+      });
+    }
+    } // end isDisabled('rust-excessive-unwrap')
+
+    // unsafe 块数量检查
+    if (!isDisabled('rust-excessive-unsafe')) {
+    let unsafeCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (/\bunsafe\s*\{/.test(lines[i]) || /\bunsafe\s+fn\b/.test(lines[i])) {
+        unsafeCount++;
+      }
+    }
+    if (unsafeCount > threshold('rust-excessive-unsafe', 3)) {
+      violations.push({
+        ruleId: 'rust-excessive-unsafe',
+        message: `文件包含 ${unsafeCount} 处 unsafe 块/函数，请审查是否都必要`,
+        severity: 'warning',
+        line: 1,
+        snippet: `${unsafeCount} unsafe blocks detected`,
+        dimension: 'file',
+        fixSuggestion: '尽量使用 safe abstraction 封装 unsafe 代码，减少 unsafe 暴露面',
+      });
+    }
+    } // end isDisabled('rust-excessive-unsafe')
+  }
+
+  // ── Dart ──
+  if (language === 'dart') {
+    // setState after dispose — Flutter 常见内存泄露
+    if (!isDisabled('dart-setstate-after-dispose') && code.includes('setState') && code.includes('dispose')) {
+      // 检查 dispose 方法后是否还有 async 回调中的 setState
+      const disposeIdx = lines.findIndex((l) => /void\s+dispose\s*\(/.test(l) || /\bsuper\.dispose\(\)/.test(l));
+      if (disposeIdx >= 0) {
+        // 检查是否有 mounted 检查保护
+        const hasMountedCheck = code.includes('if (mounted)') || code.includes('if (!mounted)');
+        if (!hasMountedCheck) {
+          violations.push({
+            ruleId: 'dart-setstate-after-dispose',
+            message: '存在 setState 调用但未检查 mounted 状态，异步回调可能在 dispose 后触发 setState',
+            severity: 'warning',
+            line: disposeIdx + 1,
+            snippet: lines[disposeIdx].trim().slice(0, 120),
+            dimension: 'file',
+            fixSuggestion: '在 setState 前添加 if (!mounted) return; 检查',
+          });
+        }
+      }
+    }
+
+    // late 变量未初始化风险
+    if (!isDisabled('dart-excessive-late')) {
+    let lateCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+      if (/\blate\s+(?!final\b)\w+/.test(lines[i]) && !lines[i].includes('=')) {
+        lateCount++;
+      }
+    }
+    if (lateCount > threshold('dart-excessive-late', 3)) {
+      violations.push({
+        ruleId: 'dart-excessive-late',
+        message: `文件有 ${lateCount} 个 late 非 final 变量且无初始值，访问未初始化变量会抛出 LateInitializationError`,
+        severity: 'warning',
+        line: 1,
+        snippet: `${lateCount} late variables without initializer`,
+        dimension: 'file',
+        fixSuggestion: '考虑使用可空类型 + null 检查，或 late final + 初始化赋值',
+      });
+    }
+    } // end isDisabled('dart-excessive-late')
+  }
+
+  return violations;
+}

package/lib/service/guard/GuardCrossFileChecks.js

@@ -0,0 +1,307 @@
+/**
+ * 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;
+}