autosnippet 3.3.0 → 3.3.3

package/dist/lib/service/evolution/ContradictionDetector.js

@@ -0,0 +1,253 @@
+/**
+ * ContradictionDetector — Recipe 级矛盾检测
+ *
+ * 从 MemoryConsolidator 提升：Memory 层只做 session 内去重，
+ * Recipe 层做跨 lifecycle 的持久化矛盾检测。
+ *
+ * 检测维度：
+ *   1. 否定模式检测（中/英双语 negation patterns）
+ *   2. 主题词重叠 ≥ 30% Jaccard
+ *   3. doClause vs dontClause 交叉引用
+ *   4. guard regex 互斥检测
+ *
+ * 结果：硬矛盾 (confidence ≥ 0.8) / 软矛盾 (0.4-0.8)
+ */
+var _a;
+import Logger from '../../infrastructure/logging/Logger.js';
+/* ────────────────────── Constants ────────────────────── */
+const NEGATION_PATTERNS_ZH = /不(再)?使用|禁止|废弃|移除|取消|停止|不要|不采用|弃用|淘汰/;
+const NEGATION_PATTERNS_EN = /\b(don'?t|do\s+not|never|no\s+longer|removed?|deprecated?|stop|avoid|disable|abandon|drop)\b/i;
+const MIN_TOPIC_OVERLAP_WORDS = 2;
+const MIN_TOPIC_OVERLAP_RATIO = 0.3;
+const STOP_WORDS = new Set([
+    '我们',
+    '使用',
+    '项目',
+    '需要',
+    '可以',
+    '应该',
+    '建议',
+    '目前',
+    '已经',
+    '这个',
+    '那个',
+    '一个',
+    '进行',
+    '通过',
+    '对于',
+    'the',
+    'is',
+    'are',
+    'was',
+    'were',
+    'be',
+    'been',
+    'have',
+    'has',
+    'had',
+    'do',
+    'does',
+    'did',
+    'will',
+    'would',
+    'could',
+    'should',
+    'may',
+    'might',
+    'can',
+    'this',
+    'that',
+    'these',
+    'those',
+    'for',
+    'and',
+    'but',
+    'with',
+    'not',
+    'from',
+    'use',
+    'all',
+    'any',
+]);
+/* ────────────────────── Class ────────────────────── */
+export class ContradictionDetector {
+    #db;
+    #signalBus;
+    #logger = Logger.getInstance();
+    constructor(db, options = {}) {
+        this.#db = db;
+        this.#signalBus = options.signalBus ?? null;
+    }
+    /**
+     * 检测所有 active/staging/evolving Recipe 之间的矛盾
+     */
+    detectAll() {
+        const recipes = this.#loadRecipes();
+        const results = [];
+        for (let i = 0; i < recipes.length; i++) {
+            for (let j = i + 1; j < recipes.length; j++) {
+                const result = this.detectPair(recipes[i], recipes[j]);
+                if (result) {
+                    results.push(result);
+                }
+            }
+        }
+        // 发射矛盾信号
+        if (this.#signalBus && results.length > 0) {
+            for (const r of results) {
+                this.#signalBus.send('lifecycle', 'ContradictionDetector', r.confidence, {
+                    target: r.recipeA,
+                    metadata: {
+                        contradictsWith: r.recipeB,
+                        type: r.type,
+                        evidence: r.evidence,
+                    },
+                });
+            }
+        }
+        this.#logger.debug(`ContradictionDetector: found ${results.length} contradictions`);
+        return results;
+    }
+    /**
+     * 检测两条 Recipe 是否矛盾
+     */
+    detectPair(a, b) {
+        const evidence = [];
+        let score = 0;
+        // 维度 1: 否定模式 + 主题重叠
+        const textA = [a.title, a.description, a.doClause, a.dontClause, a.content_markdown]
+            .filter(Boolean)
+            .join(' ');
+        const textB = [b.title, b.description, b.doClause, b.dontClause, b.content_markdown]
+            .filter(Boolean)
+            .join(' ');
+        if (this.#hasNegationConflict(textA, textB)) {
+            evidence.push('negation_pattern_conflict');
+            score += 0.4;
+        }
+        // 维度 2: doClause vs dontClause 交叉引用
+        if (a.doClause && b.dontClause && this.#hasTopicOverlap(a.doClause, b.dontClause)) {
+            evidence.push('doClause_vs_dontClause_cross');
+            score += 0.3;
+        }
+        if (b.doClause && a.dontClause && this.#hasTopicOverlap(b.doClause, a.dontClause)) {
+            evidence.push('dontClause_vs_doClause_cross');
+            score += 0.3;
+        }
+        // 维度 3: guard regex 互斥检测
+        if (a.guardPattern && b.guardPattern) {
+            if (this.#areRegexMutuallyExclusive(a.guardPattern, b.guardPattern)) {
+                evidence.push('guard_regex_mutual_exclusive');
+                score += 0.2;
+            }
+        }
+        if (evidence.length === 0) {
+            return null;
+        }
+        const confidence = Math.min(1, score);
+        const type = confidence >= 0.8 ? 'hard' : 'soft';
+        return {
+            recipeA: a.id,
+            recipeB: b.id,
+            confidence,
+            type,
+            evidence,
+        };
+    }
+    /* ── Internal ── */
+    #loadRecipes() {
+        try {
+            const rows = this.#db
+                .prepare(`SELECT id, title, lifecycle, description,
+                json_extract(content, '$.markdown') AS content_markdown,
+                doClause,
+                dontClause,
+                json_extract(content, '$.pattern') AS guardPattern
+         FROM knowledge_entries
+         WHERE lifecycle IN ('active', 'staging', 'evolving')`)
+                .all();
+            return rows.map((r) => ({
+                id: r.id,
+                title: r.title,
+                lifecycle: r.lifecycle,
+                doClause: r.doClause ?? null,
+                dontClause: r.dontClause ?? null,
+                guardPattern: r.guardPattern ?? null,
+                description: r.description ?? null,
+                content_markdown: r.content_markdown ?? null,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    #hasNegationConflict(textA, textB) {
+        if (!textA || !textB) {
+            return false;
+        }
+        const aNeg = NEGATION_PATTERNS_ZH.test(textA) || NEGATION_PATTERNS_EN.test(textA);
+        const bNeg = NEGATION_PATTERNS_ZH.test(textB) || NEGATION_PATTERNS_EN.test(textB);
+        // 同极性不算矛盾
+        if (aNeg === bNeg) {
+            return false;
+        }
+        return this.#hasTopicOverlap(textA, textB);
+    }
+    #hasTopicOverlap(textA, textB) {
+        const wordsA = _a.extractTopicWords(textA);
+        const wordsB = _a.extractTopicWords(textB);
+        let overlap = 0;
+        for (const w of wordsA) {
+            if (wordsB.has(w)) {
+                overlap++;
+            }
+        }
+        const minSize = Math.min(wordsA.size, wordsB.size);
+        if (minSize === 0) {
+            return false;
+        }
+        return overlap >= MIN_TOPIC_OVERLAP_WORDS || overlap / minSize >= MIN_TOPIC_OVERLAP_RATIO;
+    }
+    #areRegexMutuallyExclusive(patternA, patternB) {
+        // 简单启发式：如果两个 pattern 的核心词完全相同但一个含否定前缀
+        // 例如 "use.*SnapKit" vs "(?!.*SnapKit)" 或 "avoid.*SnapKit"
+        try {
+            const coreA = patternA
+                .replace(/[\\^$.*+?()[\]{}|]/g, ' ')
+                .trim()
+                .toLowerCase();
+            const coreB = patternB
+                .replace(/[\\^$.*+?()[\]{}|]/g, ' ')
+                .trim()
+                .toLowerCase();
+            const wordsA = new Set(coreA.split(/\s+/).filter((w) => w.length >= 3));
+            const wordsB = new Set(coreB.split(/\s+/).filter((w) => w.length >= 3));
+            let overlap = 0;
+            for (const w of wordsA) {
+                if (wordsB.has(w)) {
+                    overlap++;
+                }
+            }
+            // 高重叠 + 一个含否定前瞻
+            if (overlap >= 2 && (patternA.includes('(?!') || patternB.includes('(?!'))) {
+                return true;
+            }
+        }
+        catch {
+            // regex parsing error
+        }
+        return false;
+    }
+    /** 提取主题词（公开为静态方法，供 RedundancyAnalyzer 复用） */
+    static extractTopicWords(text) {
+        if (!text) {
+            return new Set();
+        }
+        const tokens = text
+            .toLowerCase()
+            .split(/[\s,;:!?。，；：！？\-_/\\|()[\]{}'"<>·、]+/)
+            .filter((t) => t.length >= 2);
+        return new Set(tokens.filter((t) => !STOP_WORDS.has(t)));
+    }
+}
+_a = ContradictionDetector;

package/dist/lib/service/evolution/DecayDetector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * DecayDetector — 知识衰退检测 + 评分
+ *
+ * 5 种衰退检测策略（任一满足即触发 decaying 转换）：
+ *   1. daysSinceLastHit > 90 — 90 天无使用
+ *   2. ruleFalsePositiveRate > 0.4 && triggers > 10 — 规则已不准
+ *   3. ReverseGuard: coreCode 引用的 API 符号已删除
+ *   4. 同域新 Recipe 发布且 deprecated_by 关系指向它
+ *   5. ContradictionDetector: 与更新的 Recipe 硬矛盾
+ *
+ * 衰退评分 (decayScore 0-100):
+ *   freshness(0.3) + usage(0.3) + quality(0.2) + authority(0.2)
+ *
+ *   80-100: 健康 → 不转换
+ *   60-79:  关注 → Dashboard 警告
+ *   40-59:  衰退 → active → decaying
+ *   20-39:  严重 → Grace Period 缩短到 15d
+ *   0-19:   死亡 → 跳过确认直接 deprecated
+ */
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+        get(...params: unknown[]): Record<string, unknown> | undefined;
+    };
+}
+export interface DecaySignal {
+    recipeId: string;
+    strategy: DecayStrategy;
+    detail: string;
+}
+export type DecayStrategy = 'no_recent_usage' | 'high_false_positive' | 'symbol_drift' | 'superseded' | 'contradiction';
+export interface DecayScoreResult {
+    recipeId: string;
+    title: string;
+    decayScore: number;
+    level: 'healthy' | 'watch' | 'decaying' | 'severe' | 'dead';
+    signals: DecaySignal[];
+    dimensions: {
+        freshness: number;
+        usage: number;
+        quality: number;
+        authority: number;
+    };
+    /** 建议的 Grace Period (ms)。severe=15d，dead=0 */
+    suggestedGracePeriod: number;
+}
+interface RecipeForDecay {
+    id: string;
+    title: string;
+    lifecycle: string;
+    stats: string | null;
+    quality_grade: string | null;
+    quality_score: number | null;
+    created_at: string | null;
+}
+export declare class DecayDetector {
+    #private;
+    constructor(db: DatabaseLike, options?: {
+        signalBus?: SignalBus;
+    });
+    /**
+     * 扫描所有 active 条目的衰退状态
+     */
+    scanAll(): DecayScoreResult[];
+    /**
+     * 评估单条 Recipe 的衰退状态
+     */
+    evaluate(recipe: RecipeForDecay): DecayScoreResult;
+}
+export {};

package/dist/lib/service/evolution/DecayDetector.js

@@ -0,0 +1,244 @@
+/**
+ * DecayDetector — 知识衰退检测 + 评分
+ *
+ * 5 种衰退检测策略（任一满足即触发 decaying 转换）：
+ *   1. daysSinceLastHit > 90 — 90 天无使用
+ *   2. ruleFalsePositiveRate > 0.4 && triggers > 10 — 规则已不准
+ *   3. ReverseGuard: coreCode 引用的 API 符号已删除
+ *   4. 同域新 Recipe 发布且 deprecated_by 关系指向它
+ *   5. ContradictionDetector: 与更新的 Recipe 硬矛盾
+ *
+ * 衰退评分 (decayScore 0-100):
+ *   freshness(0.3) + usage(0.3) + quality(0.2) + authority(0.2)
+ *
+ *   80-100: 健康 → 不转换
+ *   60-79:  关注 → Dashboard 警告
+ *   40-59:  衰退 → active → decaying
+ *   20-39:  严重 → Grace Period 缩短到 15d
+ *   0-19:   死亡 → 跳过确认直接 deprecated
+ */
+import Logger from '../../infrastructure/logging/Logger.js';
+/* ────────────────────── Constants ────────────────────── */
+const DAY_MS = 24 * 60 * 60 * 1000;
+const GRACE_PERIOD_STANDARD = 30 * DAY_MS;
+const GRACE_PERIOD_SEVERE = 15 * DAY_MS;
+const DECAY_THRESHOLDS = {
+    /** 无使用天数上限 */
+    NO_USAGE_DAYS: 90,
+    /** FP 率上限 */
+    FALSE_POSITIVE_RATE: 0.4,
+    /** FP 率可靠性所需最少触发次数 */
+    MIN_FP_TRIGGERS: 10,
+};
+const SCORE_WEIGHTS = {
+    freshness: 0.3,
+    usage: 0.3,
+    quality: 0.2,
+    authority: 0.2,
+};
+/* ────────────────────── Class ────────────────────── */
+export class DecayDetector {
+    #db;
+    #signalBus;
+    #logger = Logger.getInstance();
+    constructor(db, options = {}) {
+        this.#db = db;
+        this.#signalBus = options.signalBus ?? null;
+    }
+    /**
+     * 扫描所有 active 条目的衰退状态
+     */
+    scanAll() {
+        const recipes = this.#loadActiveRecipes();
+        const results = [];
+        for (const recipe of recipes) {
+            const result = this.evaluate(recipe);
+            results.push(result);
+        }
+        // 发射衰退信号
+        if (this.#signalBus) {
+            for (const r of results) {
+                if (r.level !== 'healthy') {
+                    this.#signalBus.send('decay', 'DecayDetector', 1 - r.decayScore / 100, {
+                        target: r.recipeId,
+                        metadata: {
+                            level: r.level,
+                            decayScore: r.decayScore,
+                            signals: r.signals.map((s) => s.strategy),
+                        },
+                    });
+                }
+            }
+        }
+        this.#logger.debug(`DecayDetector: scanned ${results.length} recipes, ${results.filter((r) => r.level !== 'healthy').length} need attention`);
+        return results;
+    }
+    /**
+     * 评估单条 Recipe 的衰退状态
+     */
+    evaluate(recipe) {
+        const stats = DecayDetector.#parseStats(recipe.stats);
+        const signals = [];
+        const now = Date.now();
+        // 策略 1: 90 天无使用
+        const lastHitAt = stats.lastHitAt ?? null;
+        if (lastHitAt) {
+            const daysSince = (now - lastHitAt) / DAY_MS;
+            if (daysSince > DECAY_THRESHOLDS.NO_USAGE_DAYS) {
+                signals.push({
+                    recipeId: recipe.id,
+                    strategy: 'no_recent_usage',
+                    detail: `No usage in ${Math.round(daysSince)} days (threshold: ${DECAY_THRESHOLDS.NO_USAGE_DAYS}d)`,
+                });
+            }
+        }
+        else {
+            // 无 lastHitAt，检查创建时间
+            const createdAt = recipe.created_at ? new Date(recipe.created_at).getTime() : now;
+            const daysSinceCreation = (now - createdAt) / DAY_MS;
+            if (daysSinceCreation > DECAY_THRESHOLDS.NO_USAGE_DAYS) {
+                signals.push({
+                    recipeId: recipe.id,
+                    strategy: 'no_recent_usage',
+                    detail: `Never used, created ${Math.round(daysSinceCreation)} days ago`,
+                });
+            }
+        }
+        // 策略 2: 高 FP 率
+        const fpRate = stats.ruleFalsePositiveRate ?? 0;
+        const triggers = stats.guardHits ?? 0;
+        if (fpRate > DECAY_THRESHOLDS.FALSE_POSITIVE_RATE &&
+            triggers >= DECAY_THRESHOLDS.MIN_FP_TRIGGERS) {
+            signals.push({
+                recipeId: recipe.id,
+                strategy: 'high_false_positive',
+                detail: `FP rate ${(fpRate * 100).toFixed(0)}% with ${triggers} triggers (threshold: ${DECAY_THRESHOLDS.FALSE_POSITIVE_RATE * 100}%)`,
+            });
+        }
+        // 策略 3: 符号漂移（由 ReverseGuard 提供，此处从 DB 查 drift 标记）
+        if (this.#hasSymbolDrift(recipe.id)) {
+            signals.push({
+                recipeId: recipe.id,
+                strategy: 'symbol_drift',
+                detail: 'ReverseGuard detected symbol drift in coreCode',
+            });
+        }
+        // 策略 4: 被取代（有 deprecated_by 关系指向更新版本）
+        if (this.#isSuperseded(recipe.id)) {
+            signals.push({
+                recipeId: recipe.id,
+                strategy: 'superseded',
+                detail: 'Newer version exists via deprecated_by relation',
+            });
+        }
+        // 计算 decayScore
+        const dimensions = this.#computeScoreDimensions(stats, recipe);
+        const decayScore = Math.round(dimensions.freshness * SCORE_WEIGHTS.freshness * 100 +
+            dimensions.usage * SCORE_WEIGHTS.usage * 100 +
+            dimensions.quality * SCORE_WEIGHTS.quality * 100 +
+            dimensions.authority * SCORE_WEIGHTS.authority * 100);
+        const level = DecayDetector.#scoreToLevel(decayScore);
+        const suggestedGracePeriod = level === 'dead' ? 0 : level === 'severe' ? GRACE_PERIOD_SEVERE : GRACE_PERIOD_STANDARD;
+        return {
+            recipeId: recipe.id,
+            title: recipe.title,
+            decayScore,
+            level,
+            signals,
+            dimensions,
+            suggestedGracePeriod,
+        };
+    }
+    /* ── Internal ── */
+    #loadActiveRecipes() {
+        try {
+            const rows = this.#db
+                .prepare(`SELECT id, title, lifecycle, stats, quality_grade, quality_score, created_at
+         FROM knowledge_entries
+         WHERE lifecycle = 'active'`)
+                .all();
+            return rows.map((r) => ({
+                id: r.id,
+                title: r.title,
+                lifecycle: r.lifecycle,
+                stats: r.stats ?? null,
+                quality_grade: r.quality_grade ?? null,
+                quality_score: r.quality_score !== undefined ? Number(r.quality_score) : null,
+                created_at: r.created_at ?? null,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    static #parseStats(statsJson) {
+        if (!statsJson) {
+            return {};
+        }
+        try {
+            return JSON.parse(statsJson);
+        }
+        catch {
+            return {};
+        }
+    }
+    #computeScoreDimensions(stats, recipe) {
+        const now = Date.now();
+        // freshness: days since last hit → 0-1 (0 = 365+ days, 1 = today)
+        const lastHit = stats.lastHitAt ?? 0;
+        const daysSinceHit = lastHit > 0 ? (now - lastHit) / DAY_MS : 365;
+        const freshness = Math.max(0, 1 - daysSinceHit / 365);
+        // usage: hitsLast90d 归一化 (0 = 0 hits, 1 = 50+ hits)
+        const hitsLast90d = stats.hitsLast90d ?? 0;
+        const usage = Math.min(1, hitsLast90d / 50);
+        // quality: qualityScore 直接使用
+        const quality = recipe.quality_score ?? 0.5;
+        // authority: from stats.authority 归一化 (0-100 → 0-1)
+        const authorityRaw = stats.authority ?? 50;
+        const authority = Math.min(1, authorityRaw / 100);
+        return { freshness, usage, quality, authority };
+    }
+    #hasSymbolDrift(recipeId) {
+        try {
+            // 查找 audit_logs 中 ReverseGuard 为此 recipe 发过 drift 信号
+            const row = this.#db
+                .prepare(`SELECT 1 FROM audit_logs
+         WHERE action LIKE '%ReverseGuard%'
+           AND json_extract(details, '$.target') = ?
+         LIMIT 1`)
+                .get(recipeId);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
+    #isSuperseded(recipeId) {
+        try {
+            const row = this.#db
+                .prepare(`SELECT 1 FROM knowledge_edges
+         WHERE source_id = ? AND relation_type = 'deprecated_by'
+         LIMIT 1`)
+                .get(recipeId);
+            return !!row;
+        }
+        catch {
+            return false;
+        }
+    }
+    static #scoreToLevel(score) {
+        if (score >= 80) {
+            return 'healthy';
+        }
+        if (score >= 60) {
+            return 'watch';
+        }
+        if (score >= 40) {
+            return 'decaying';
+        }
+        if (score >= 20) {
+            return 'severe';
+        }
+        return 'dead';
+    }
+}

package/dist/lib/service/evolution/EnhancementSuggester.d.ts

@@ -0,0 +1,38 @@
+/**
+ * EnhancementSuggester — 使用数据反推增强建议
+ *
+ * 4 种增强策略：
+ *   ① Guard 频繁命中但无 coreCode → 建议补充代码示例
+ *   ② Search 高频命中但 adoptions=0 → 建议改善 usageGuide
+ *   ③ 同类知识中 authority 偏低 → 建议补充 whenClause
+ *   ④ 关联 Recipe 已 deprecated → 建议检查引用是否过时
+ */
+import type { ReportStore } from '../../infrastructure/report/ReportStore.js';
+import type { SignalBus } from '../../infrastructure/signal/SignalBus.js';
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+        get(...params: unknown[]): Record<string, unknown> | undefined;
+    };
+}
+export type EnhancementType = 'missing_code_example' | 'low_adoption' | 'low_authority' | 'deprecated_reference';
+export interface EnhancementSuggestion {
+    recipeId: string;
+    title: string;
+    type: EnhancementType;
+    description: string;
+    priority: 'high' | 'medium' | 'low';
+    evidence: string[];
+}
+export declare class EnhancementSuggester {
+    #private;
+    constructor(db: DatabaseLike, options?: {
+        signalBus?: SignalBus;
+        reportStore?: ReportStore;
+    });
+    /**
+     * 运行全部 4 种增强策略
+     */
+    analyzeAll(): EnhancementSuggestion[];
+}
+export {};