autosnippet 3.2.21 → 3.3.2

package/dist/lib/service/guard/CoverageAnalyzer.js

@@ -0,0 +1,149 @@
+/**
+ * CoverageAnalyzer — Guard 覆盖率矩阵 + Panorama 协同
+ *
+ * 计算模块级 Rule 覆盖率，识别零覆盖和低覆盖模块。
+ * 与 PanoramaService 协同：利用模块划分 + gaps 数据做精准评估。
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+import { LanguageService } from '../../shared/LanguageService.js';
+/* ────────────────────── 常量 ────────────────────── */
+const LOW_COVERAGE_THRESHOLD = 50;
+/* ────────────────────── Class ────────────────────── */
+export class CoverageAnalyzer {
+    #db;
+    #ruleLearner;
+    #logger = Logger.getInstance();
+    constructor(db, options = {}) {
+        this.#db = db;
+        this.#ruleLearner = options.ruleLearner ?? null;
+    }
+    /**
+     * 计算覆盖率矩阵
+     * @param moduleFiles 模块名 → 文件路径列表的映射
+     */
+    analyze(moduleFiles) {
+        // 1. 加载所有 active rule recipes
+        const rules = this.#loadActiveRules();
+        // 2. 构建 rule → 文件路径映射 (从 guard_violations 历史推断)
+        const ruleFileMap = this.#buildRuleFileMap();
+        // 3. 加载规则健康数据
+        const allStats = this.#ruleLearner?.getAllStats() ?? {};
+        // 4. 对每个模块计算覆盖率
+        const modules = [];
+        for (const [moduleName, files] of moduleFiles) {
+            if (files.length === 0) {
+                modules.push({
+                    module: moduleName,
+                    ruleCount: 0,
+                    fpRate: 0,
+                    coverage: 0,
+                    level: 'zero',
+                });
+                continue;
+            }
+            // 找出与该模块文件匹配的 rule
+            const fileSet = new Set(files);
+            const matchedRules = new Set();
+            // 方式 1: rule 的 guard_violations 历史曾命中该模块的文件
+            for (const [ruleId, rulePaths] of ruleFileMap) {
+                for (const rp of rulePaths) {
+                    if (fileSet.has(rp)) {
+                        matchedRules.add(ruleId);
+                        break;
+                    }
+                }
+            }
+            // 方式 2: rule 的 scope/language 与模块语言匹配 (基于文件扩展名推断)
+            const moduleLanguages = this.#inferLanguages(files);
+            for (const rule of rules) {
+                if (rule.languages.length === 0 || rule.languages.some((l) => moduleLanguages.has(l))) {
+                    matchedRules.add(rule.id);
+                }
+            }
+            const ruleCount = matchedRules.size;
+            // 计算该模块关联规则的平均 FP 率
+            let fpRateSum = 0;
+            let fpRuleCount = 0;
+            for (const ruleId of matchedRules) {
+                const stat = allStats[ruleId];
+                if (stat?.triggers && stat.triggers > 0) {
+                    const metrics = this.#ruleLearner?.getMetrics(ruleId);
+                    if (metrics) {
+                        fpRateSum += metrics.falsePositiveRate;
+                        fpRuleCount++;
+                    }
+                }
+            }
+            const fpRate = fpRuleCount > 0 ? Math.round((fpRateSum / fpRuleCount) * 100) : 0;
+            // 覆盖率 = 匹配到的规则数 / (模块文件数 × 权重因子)
+            // 简化公式: 每个文件理论上应有 ≥1 条规则覆盖
+            const coverage = Math.min(100, Math.round((ruleCount / Math.max(1, files.length)) * 100));
+            const level = coverage === 0 ? 'zero' : coverage < LOW_COVERAGE_THRESHOLD ? 'low' : 'good';
+            modules.push({ module: moduleName, ruleCount, fpRate, coverage, level });
+        }
+        // 5. 总体覆盖率
+        const totalModules = modules.length;
+        const overallCoverage = totalModules > 0
+            ? Math.round(modules.reduce((sum, m) => sum + m.coverage, 0) / totalModules)
+            : 0;
+        const zeroModules = modules.filter((m) => m.level === 'zero').map((m) => m.module);
+        const lowModules = modules.filter((m) => m.level === 'low').map((m) => m.module);
+        return { modules, overallCoverage, zeroModules, lowModules };
+    }
+    /* ── 内部 ── */
+    #loadActiveRules() {
+        try {
+            const rows = this.#db
+                .prepare(`SELECT id, language FROM knowledge_entries WHERE lifecycle = 'active' AND kind = 'rule'`)
+                .all();
+            return rows.map((r) => ({
+                id: r.id,
+                languages: r.language
+                    ? r.language.split(',').map((l) => LanguageService.normalize(l.trim()))
+                    : [],
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    #buildRuleFileMap() {
+        const map = new Map();
+        try {
+            const rows = this.#db
+                .prepare(`SELECT file_path, violations_json FROM guard_violations ORDER BY created_at DESC LIMIT 200`)
+                .all();
+            for (const row of rows) {
+                try {
+                    const violations = JSON.parse(row.violations_json || '[]');
+                    const filePath = row.file_path;
+                    for (const v of violations) {
+                        if (!v.ruleId) {
+                            continue;
+                        }
+                        const list = map.get(v.ruleId) || [];
+                        list.push(filePath);
+                        map.set(v.ruleId, list);
+                    }
+                }
+                catch {
+                    // invalid json
+                }
+            }
+        }
+        catch {
+            // table doesn't exist
+        }
+        return map;
+    }
+    #inferLanguages(files) {
+        const langs = new Set();
+        for (const f of files) {
+            const lang = LanguageService.inferLang(f);
+            if (lang !== 'unknown') {
+                langs.add(lang);
+            }
+        }
+        return langs;
+    }
+}

package/dist/lib/service/guard/GuardCheckEngine.d.ts

@@ -6,6 +6,9 @@
  */
 import * as AstAnalyzerModule from '../../core/AstAnalyzer.js';
 import Logger from '../../infrastructure/logging/Logger.js';
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
+import type { GuardCapabilityReport, UncertainResult } from './UncertaintyCollector.js';
+import { UncertaintyCollector } from './UncertaintyCollector.js';
 /** Minimal DB interface for Guard engine */
 interface DatabaseLike {
     prepare(sql: string): {
@@ -24,6 +27,7 @@ interface BuiltInRule {
     category?: string;
     fixSuggestion?: string;
     excludePaths?: RegExp;
+    excludeLinePatterns?: string[];
     skipComments?: boolean;
     skipTestBlocks?: boolean;
 }
@@ -40,6 +44,7 @@ interface GuardRule {
     type?: string;
     fixSuggestion?: string | null;
     excludePaths?: RegExp | string;
+    excludeLinePatterns?: string[];
     skipComments?: boolean;
     skipTestBlocks?: boolean;
     astQuery?: {
@@ -62,13 +67,19 @@ interface GuardViolation {
         suggestedFix: string | null;
     };
 }
+/** 每条规则的覆盖配置（支持数字阈值或富对象） */
+interface RuleOverride {
+    severity?: string;
+    exclude?: string[];
+}
 interface GuardConfig {
     disabledRules?: string[];
-    codeLevelThresholds?: Record<string, number>;
+    codeLevelThresholds?: Record<string, number | RuleOverride>;
 }
 interface GuardCheckEngineOptions {
     cacheTTL?: number;
     guardConfig?: GuardConfig;
+    signalBus?: SignalBus;
 }
 interface ExternalRuleInput {
     ruleId: string;
@@ -84,10 +95,12 @@ interface AuditFileResult {
     filePath: string;
     language: string;
     violations: GuardViolation[];
+    uncertainResults: UncertainResult[];
     summary: {
         total: number;
         errors: number;
         warnings: number;
+        uncertain: number;
     };
 }
 interface AuditFilesInput {
@@ -105,6 +118,11 @@ export declare class GuardCheckEngine {
     _epInjected: boolean;
     _externalRules: Map<string, GuardRule>;
     _guardConfig: GuardConfig;
+    _signalBus: SignalBus | null;
+    /** 上次 guard 信号指纹，用于去重（相同结果不重复发射） */
+    _lastGuardSignalKey: string;
+    _lastBlindSpotSignalKey: string;
+    _uncertaintyCollector: UncertaintyCollector;
     db: DatabaseLike;
     logger: ReturnType<typeof Logger.getInstance>;
     constructor(db: DatabaseLike | {
@@ -155,8 +173,40 @@ export declare class GuardCheckEngine {
      * @returns violations
      */
     _runAstRuleChecks(code: string, language: string): GuardViolation[];
+    /**
+     * AST Layer 2: analyzeFile() 深层检查
+     *
+     * 利用 AstAnalyzer.analyzeFile() 的完整输出产出 violations:
+     *
+     * --- 方法度量 ---
+     *   - ast_class_bloat: 类方法数过多 (>20)
+     *   - ast_method_complexity: 高圈复杂度 (>15)
+     *   - ast_method_too_long: 方法行数过长 (>80)
+     *   - ast_deep_nesting: 方法嵌套过深 (>5)
+     *
+     * --- 继承图检查 ---
+     *   - ast_deep_inheritance: 继承链过深 (>4)
+     *   - ast_wide_protocol_conformance: 单类遵守协议过多 (>5)
+     *   - ast_missing_super: 子类未调用 super 的关键方法
+     *
+     * --- 属性规范 ---
+     *   - ast_assign_object_property: ObjC assign 修饰对象类型属性
+     *   - ast_missing_nonatomic: ObjC 属性缺少 nonatomic
+     *   - ast_mutable_public_collection: 公开可变集合属性
+     *
+     * --- 设计模式/反模式检测 ---
+     *   - ast_god_class: 方法+属性过多的上帝类 (>30 methods + >15 properties)
+     *   - ast_singleton_abuse: 过多单例模式
+     *   - ast_missing_weakify: block 内 self 捕获但未使用 weakify
+     */
+    _runAstLayer2Checks(code: string, language: string, filePath: string): GuardViolation[];
     /** 获取 AstAnalyzer 模块（静态 import，带可用性检测） */
     _getAstAnalyzer(): typeof AstAnalyzerModule;
+    /**
+     * 合并内置 + 配置级行排除模式，编译为 RegExp 数组
+     * 配置来自 guardConfig.codeLevelThresholds[ruleId].exclude
+     */
+    _getExcludeLineRegexes(ruleId: string, builtIn?: string[]): RegExp[];
     /**
      * 将 Guard 命中计数回写到对应 Recipe 的 guard_hit_count
      * @param violations
@@ -186,9 +236,13 @@ export declare class GuardCheckEngine {
             filesChecked: number;
             totalViolations: number;
             totalErrors: number;
+            totalUncertain: number;
             filesWithViolations: number;
         };
+        capabilityReport: GuardCapabilityReport;
     };
+    /** 获取 uncertainty collector（供外部读取单文件 uncertain 状态） */
+    getUncertaintyCollector(): UncertaintyCollector;
     /** 清除规则缓存 */
     clearCache(): void;
     /** 获取内置规则列表 */