autosnippet 3.2.21 → 3.3.2

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

@@ -36,6 +36,7 @@ export declare class ViolationsStore {
     constructor(db: DatabaseLike, drizzle?: DrizzleDB);
     /**
      * 追加一次 Guard 运行记录
+     * ★ 去重：同一文件、同一违规集合不重复入库，仅更新时间戳
      * ★ Drizzle 类型安全 INSERT + raw SQL 截断
      */
     appendRun(run: RunInput): string;

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

@@ -18,20 +18,41 @@ export class ViolationsStore {
     // ─── 写入 ─────────────────────────────────────────────
     /**
      * 追加一次 Guard 运行记录
+     * ★ 去重：同一文件、同一违规集合不重复入库，仅更新时间戳
      * ★ Drizzle 类型安全 INSERT + raw SQL 截断
      */
     appendRun(run) {
+        const filePath = run.filePath || '';
+        const violations = run.violations || [];
+        const violationsJson = JSON.stringify(violations);
+        // ── 去重：查最近一条同文件记录，比较违规指纹 ──
+        const fingerprint = this.#violationFingerprint(violations);
+        if (filePath) {
+            const lastRow = this.#db
+                .prepare(`SELECT id, violations_json FROM guard_violations WHERE file_path = ? ORDER BY created_at DESC LIMIT 1`)
+                .get(filePath);
+            if (lastRow) {
+                const lastFingerprint = this.#violationFingerprint(JSON.parse(lastRow.violations_json || '[]'));
+                if (fingerprint === lastFingerprint) {
+                    // 违规未变化：仅刷新时间戳，不新增行
+                    this.#db
+                        .prepare(`UPDATE guard_violations SET triggered_at = ?, created_at = ? WHERE id = ?`)
+                        .run(new Date().toISOString(), Math.floor(Date.now() / 1000), lastRow.id);
+                    return lastRow.id;
+                }
+            }
+        }
         const id = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
         const now = Math.floor(Date.now() / 1000);
         this.#drizzle
             .insert(guardViolations)
             .values({
             id,
-            filePath: run.filePath || '',
+            filePath,
             triggeredAt: new Date().toISOString(),
-            violationCount: (run.violations || []).length,
+            violationCount: violations.length,
             summary: run.summary || '',
-            violationsJson: JSON.stringify(run.violations || []),
+            violationsJson,
             createdAt: now,
         })
             .run();
@@ -45,6 +66,15 @@ export class ViolationsStore {
             .run(MAX_RUNS);
         return id;
     }
+    /**
+     * 违规指纹：按 ruleId+severity+line 排序后拼接，用于去重比较
+     */
+    #violationFingerprint(violations) {
+        return violations
+            .map((v) => `${v.ruleId || ''}|${v.severity || ''}|${v.line ?? ''}`)
+            .sort()
+            .join('\n');
+    }
     // ─── 查询 ─────────────────────────────────────────────
     /**
      * 获取所有运行记录（最新在后）

package/dist/lib/service/knowledge/ConfidenceRouter.d.ts

@@ -8,11 +8,18 @@ interface ConfidenceRouterConfig {
     requireReasoning?: boolean;
     trustedSources?: string[];
     trustedAutoApproveThreshold?: number;
+    highConfidenceThreshold?: number;
+    standardGracePeriod?: number;
+    highConfidenceGracePeriod?: number;
 }
 interface RouteResult {
     action: 'auto_approve' | 'pending' | 'reject';
     reason: string;
     confidence?: number;
+    /** 目标生命周期状态（六态状态机） */
+    targetState?: 'staging' | 'pending' | 'deprecated';
+    /** Grace Period（毫秒）— staging → active 自动转换等待时间 */
+    gracePeriod?: number;
 }
 /**
  * ConfidenceRouter — 知识条目自动审核路由器
@@ -38,6 +45,12 @@ declare const DEFAULT_CONFIG: {
     trustedSources: string[];
     /** 可信来源的自动通过阈值 */
     trustedAutoApproveThreshold: number;
+    /** 极高置信度阈值 (≥0.90 → 24h Grace) */
+    highConfidenceThreshold: number;
+    /** 标准 Grace Period（72h）— staging → active */
+    standardGracePeriod: number;
+    /** 高置信度 Grace Period（24h） */
+    highConfidenceGracePeriod: number;
 };
 export declare class ConfidenceRouter {
     _config: Required<typeof DEFAULT_CONFIG>;

package/dist/lib/service/knowledge/ConfidenceRouter.js

@@ -23,6 +23,12 @@ const DEFAULT_CONFIG = {
     trustedSources: ['bootstrap', 'cursor-scan'],
     /** 可信来源的自动通过阈值 */
     trustedAutoApproveThreshold: 0.7,
+    /** 极高置信度阈值 (≥0.90 → 24h Grace) */
+    highConfidenceThreshold: 0.9,
+    /** 标准 Grace Period（72h）— staging → active */
+    standardGracePeriod: 72 * 60 * 60 * 1000,
+    /** 高置信度 Grace Period（24h） */
+    highConfidenceGracePeriod: 24 * 60 * 60 * 1000,
 };
 export class ConfidenceRouter {
     _config;
@@ -56,6 +62,7 @@ export class ConfidenceRouter {
                 action: 'reject',
                 reason: `Confidence too low: ${confidence.toFixed(2)} < ${this._config.rejectThreshold}`,
                 confidence,
+                targetState: 'deprecated',
             };
         }
         // ── 阶段 3: 内容最短长度检查 ──
@@ -115,12 +122,19 @@ export class ConfidenceRouter {
                     action: 'pending',
                     reason: `Confidence OK (${confidence.toFixed(2)}) but quality low (${qualityScore.toFixed(2)})`,
                     confidence,
+                    targetState: 'pending',
                 };
             }
+            // 分级 Grace Period: ≥0.90 → 24h, 0.85-0.89 → 72h
+            const gracePeriod = confidence >= this._config.highConfidenceThreshold
+                ? this._config.highConfidenceGracePeriod
+                : this._config.standardGracePeriod;
             return {
                 action: 'auto_approve',
                 reason: `Confidence ${confidence.toFixed(2)} >= threshold ${threshold} (source: ${source})`,
                 confidence,
+                targetState: 'staging',
+                gracePeriod,
             };
         }
         // ── 默认: 需要人工审核 ──

package/dist/lib/service/knowledge/KnowledgeService.js

@@ -67,17 +67,25 @@ export class KnowledgeService {
                     throw new ValidationError(`SkillHook blocked: ${hookResult.reason || 'unknown'}`);
                 }
             }
-            // ── ConfidenceRouter — 标记 auto_approvable ──
+            // ── ConfidenceRouter — staging 路由 ──
             if (this._confidenceRouter) {
                 const route = await this._confidenceRouter.route(entry);
                 if (route.action === 'auto_approve') {
                     entry.autoApprovable = true;
+                    // 六态状态机：高置信度条目进入 staging
+                    if (route.targetState === 'staging' && route.gracePeriod) {
+                        entry.lifecycle = Lifecycle.STAGING;
+                        entry.stagingDeadline = Date.now() + route.gracePeriod;
+                    }
+                }
+                else if (route.action === 'reject' && route.targetState === 'deprecated') {
+                    entry.lifecycle = Lifecycle.DEPRECATED;
                 }
-                // reject / pending 都保持 pending 状态，等待人工审核
+                // pending 保持不变
             }
-            // 注意: Bootstrap 候选保持 pending 状态，由 Dashboard 审核后发布。
+            // 注意: staging 条目由 StagingManager.checkAndPromote() 在到期后自动转为 active。
             // autoApprovable 标记保留，供前端显示「推荐批准」徽章。
-            // CursorDelivery 已支持高置信度 pending 条目的交付。
+            // CursorDelivery 已支持高置信度 staging/pending 条目的交付。
             const saved = await this.repository.create(entry);
             // 同步 relations → knowledge_edges
             this._syncRelationsToGraph(saved.id, saved.relations);
@@ -583,6 +591,16 @@ export class KnowledgeService {
                 to: entry.lifecycle,
                 actor: context.userId,
             });
+            // EventBus: 通知生命周期状态转换（Dashboard 实时更新 + SignalBus）
+            if (this._eventBus) {
+                this._eventBus.emit('lifecycle:transition', {
+                    entryId: id,
+                    from: prevLifecycle,
+                    to: entry.lifecycle,
+                    method,
+                    actor: context.userId,
+                });
+            }
             return updated;
         }
         catch (error) {

package/dist/lib/service/module/ModuleService.js

@@ -366,19 +366,9 @@ export class ModuleService {
         if (!Array.isArray(recipes)) {
             recipes = [];
         }
-        // 3.5 Header 路径解析 + moduleName 注入
-        try {
-            const PathFinder = await import('../../platform/ios/spm/PathFinder.js');
-            const HeaderResolver = await import('../../platform/ios/xcode/HeaderResolver.js');
-            const targetRootDir = await PathFinder.findTargetRootDir(files[0].path);
-            for (const recipe of recipes) {
-                const headerList = (recipe.headers || []);
-                recipe.headerPaths = await Promise.all(headerList.map((h) => HeaderResolver.resolveHeaderRelativePath(h, targetRootDir)));
-                recipe.moduleName = targetName;
-            }
-        }
-        catch (err) {
-            this.#logger.warn(`[ModuleService] Header resolution failed: ${err.message}`);
+        // 3.5 moduleName 注入
+        for (const recipe of recipes) {
+            recipe.moduleName = targetName;
         }
         // 4. 工具增强
         onProgress?.({ type: 'scan:enriching', recipeCount: recipes.length });

package/dist/lib/service/panorama/CouplingAnalyzer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CouplingAnalyzer — 模块耦合分析
+ *
+ * 三边融合 (import + call + dataFlow) 构建加权依赖图，
+ * 使用 Tarjan SCC 检测循环依赖，计算 fanIn/fanOut。
+ *
+ * @module CouplingAnalyzer
+ */
+import type { CeDbLike, CyclicDependency, Edge } from './PanoramaTypes.js';
+export interface CouplingMetrics {
+    fanIn: number;
+    fanOut: number;
+}
+export interface CouplingResult {
+    cycles: CyclicDependency[];
+    metrics: Map<string, CouplingMetrics>;
+    edges: Edge[];
+}
+export declare class CouplingAnalyzer {
+    #private;
+    constructor(db: CeDbLike, projectRoot: string);
+    /**
+     * 分析模块间耦合关系
+     * @param moduleFiles - Map<moduleName, filePaths[]>
+     */
+    analyze(moduleFiles: Map<string, string[]>): CouplingResult;
+}

package/dist/lib/service/panorama/CouplingAnalyzer.js

@@ -0,0 +1,192 @@
+/**
+ * CouplingAnalyzer — 模块耦合分析
+ *
+ * 三边融合 (import + call + dataFlow) 构建加权依赖图，
+ * 使用 Tarjan SCC 检测循环依赖，计算 fanIn/fanOut。
+ *
+ * @module CouplingAnalyzer
+ */
+/* ═══ Edge Weights ════════════════════════════════════════ */
+const EDGE_WEIGHTS = {
+    depends_on: 0.5,
+    calls: 1.0,
+    data_flow: 0.8,
+};
+/* ═══ CouplingAnalyzer Class ══════════════════════════════ */
+export class CouplingAnalyzer {
+    #db;
+    #projectRoot;
+    constructor(db, projectRoot) {
+        this.#db = db;
+        this.#projectRoot = projectRoot;
+    }
+    /**
+     * 分析模块间耦合关系
+     * @param moduleFiles - Map<moduleName, filePaths[]>
+     */
+    analyze(moduleFiles) {
+        // 1. 构建 file → module 反向索引
+        const fileToModule = new Map();
+        for (const [mod, files] of moduleFiles) {
+            for (const f of files) {
+                fileToModule.set(f, mod);
+            }
+        }
+        // 2. 从 knowledge_edges 聚合模块间边
+        const edges = this.#buildModuleEdges(moduleFiles, fileToModule);
+        // 3. 建图
+        const adjacency = new Map();
+        const allModules = new Set(moduleFiles.keys());
+        for (const edge of edges) {
+            allModules.add(edge.from);
+            allModules.add(edge.to);
+            if (!adjacency.has(edge.from)) {
+                adjacency.set(edge.from, new Map());
+            }
+            const existing = adjacency.get(edge.from).get(edge.to) ?? 0;
+            adjacency.get(edge.from).set(edge.to, existing + edge.weight);
+        }
+        // 4. Tarjan SCC
+        const cycles = this.#tarjanSCC(adjacency, allModules);
+        // 5. fanIn / fanOut
+        const metrics = new Map();
+        for (const mod of allModules) {
+            metrics.set(mod, { fanIn: 0, fanOut: 0 });
+        }
+        for (const edge of edges) {
+            if (edge.from === edge.to) {
+                continue;
+            }
+            const fromM = metrics.get(edge.from);
+            const toM = metrics.get(edge.to);
+            if (fromM) {
+                fromM.fanOut++;
+            }
+            if (toM) {
+                toM.fanIn++;
+            }
+        }
+        // 去重边 (同 from→to 聚合)
+        const dedupEdges = this.#deduplicateEdges(edges);
+        return { cycles, metrics, edges: dedupEdges };
+    }
+    /* ─── Internal helpers ──────────────────────────── */
+    #buildModuleEdges(moduleFiles, fileToModule) {
+        const edges = [];
+        const relations = ['depends_on', 'calls', 'data_flow'];
+        for (const relation of relations) {
+            const weight = EDGE_WEIGHTS[relation] ?? 0.5;
+            // 查询该类型的边（仅限当前项目：至少 from 侧实体属于本项目）
+            const rows = this.#db
+                .prepare(`SELECT ke.from_id, ke.from_type, ke.to_id, ke.to_type
+           FROM knowledge_edges ke
+           WHERE ke.relation = ?
+           AND (
+             ke.from_type = 'module'
+             OR EXISTS (
+               SELECT 1 FROM code_entities ce
+               WHERE ce.entity_id = ke.from_id AND ce.project_root = ?
+             )
+           )`)
+                .all(relation, this.#projectRoot);
+            for (const row of rows) {
+                const fromId = row.from_id;
+                const toId = row.to_id;
+                const fromType = row.from_type;
+                const toType = row.to_type;
+                // module-to-module 直接边 (depends_on)
+                if (fromType === 'module' && toType === 'module') {
+                    if (fromId !== toId && moduleFiles.has(fromId) && moduleFiles.has(toId)) {
+                        edges.push({ from: fromId, to: toId, weight, relation });
+                    }
+                    continue;
+                }
+                // entity-to-entity 边 → 解析 file → module
+                const fromModule = this.#resolveEntityModule(fromId, fromType, fileToModule);
+                const toModule = this.#resolveEntityModule(toId, toType, fileToModule);
+                if (fromModule && toModule && fromModule !== toModule) {
+                    edges.push({ from: fromModule, to: toModule, weight, relation });
+                }
+            }
+        }
+        return edges;
+    }
+    #resolveEntityModule(entityId, _entityType, fileToModule) {
+        // 先查实体所在文件
+        const row = this.#db
+            .prepare(`SELECT file_path FROM code_entities
+         WHERE entity_id = ? AND project_root = ? LIMIT 1`)
+            .get(entityId, this.#projectRoot);
+        if (!row?.file_path) {
+            return null;
+        }
+        return fileToModule.get(row.file_path) ?? null;
+    }
+    /**
+     * Tarjan 强连通分量算法
+     */
+    #tarjanSCC(adjacency, allNodes) {
+        let index = 0;
+        const stack = [];
+        const onStack = new Set();
+        const indices = new Map();
+        const lowlinks = new Map();
+        const sccs = [];
+        const strongConnect = (v) => {
+            indices.set(v, index);
+            lowlinks.set(v, index);
+            index++;
+            stack.push(v);
+            onStack.add(v);
+            const neighbors = adjacency.get(v);
+            if (neighbors) {
+                for (const w of neighbors.keys()) {
+                    if (!indices.has(w)) {
+                        strongConnect(w);
+                        lowlinks.set(v, Math.min(lowlinks.get(v), lowlinks.get(w)));
+                    }
+                    else if (onStack.has(w)) {
+                        lowlinks.set(v, Math.min(lowlinks.get(v), indices.get(w)));
+                    }
+                }
+            }
+            if (lowlinks.get(v) === indices.get(v)) {
+                const scc = [];
+                let w;
+                do {
+                    w = stack.pop();
+                    onStack.delete(w);
+                    scc.push(w);
+                } while (w !== v);
+                sccs.push(scc);
+            }
+        };
+        for (const node of allNodes) {
+            if (!indices.has(node)) {
+                strongConnect(node);
+            }
+        }
+        // 过滤出 size > 1 的 SCC (即循环依赖)
+        return sccs
+            .filter((scc) => scc.length > 1)
+            .map((cycle) => ({
+            cycle: cycle.reverse(),
+            severity: cycle.length > 3 ? 'error' : 'warning',
+        }));
+    }
+    #deduplicateEdges(edges) {
+        const key = (e) => `${e.from}→${e.to}`;
+        const map = new Map();
+        for (const e of edges) {
+            const k = key(e);
+            const existing = map.get(k);
+            if (existing) {
+                existing.weight = Math.max(existing.weight, e.weight);
+            }
+            else {
+                map.set(k, { ...e });
+            }
+        }
+        return [...map.values()];
+    }
+}

package/dist/lib/service/panorama/DimensionAnalyzer.d.ts

@@ -0,0 +1,28 @@
+/**
+ * DimensionAnalyzer — 多维度知识健康分析
+ *
+ * 灵感来源:
+ *   - ISO/IEC 25010 质量模型 (8 大特性: 可靠性、安全性、可维护性…)
+ *   - ThoughtWorks Tech Radar (Adopt/Trial/Assess/Hold 四环)
+ *   - 雷达图/蛛网图可视化模型
+ *
+ * 核心思路: 不再按「模块 × 文件数」衡量覆盖，
+ * 而是按「知识维度」衡量项目在各工程方向上的规范成熟度。
+ * 某维度 Recipe 为 0 → 该方向完全空白，标示为 gap。
+ *
+ * @module DimensionAnalyzer
+ */
+import type { CeDbLike, HealthRadar, KnowledgeGap } from './PanoramaTypes.js';
+export declare class DimensionAnalyzer {
+    #private;
+    constructor(db: CeDbLike);
+    /**
+     * 分析项目知识健康雷达
+     *
+     * @param moduleRoles — 项目中存在的模块角色 (用于 gap 优先级推断)
+     */
+    analyze(moduleRoles: string[]): {
+        radar: HealthRadar;
+        gaps: KnowledgeGap[];
+    };
+}