autosnippet 3.3.0 → 3.3.3

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/knowledge/SourceRefReconciler.d.ts

@@ -0,0 +1,68 @@
+/**
+ * SourceRefReconciler — Recipe 来源引用健康检查 + 自动修复
+ *
+ * 从 knowledge_entries.reasoning.sources 填充 recipe_source_refs 桥接表，
+ * 验证路径存在性，检测 git rename，修复路径引用。
+ *
+ * 状态机:
+ *   active  — 文件存在，路径有效
+ *   renamed — 文件已移动到 new_path，等待修复
+ *   stale   — 路径失效，无法自动修复
+ */
+interface DatabaseLike {
+    prepare(sql: string): {
+        all(...params: unknown[]): Record<string, unknown>[];
+        get(...params: unknown[]): Record<string, unknown> | undefined;
+        run(...params: unknown[]): {
+            changes: number;
+        };
+    };
+}
+export interface ReconcileReport {
+    /** 新插入的 sourceRef 条目 */
+    inserted: number;
+    /** 验证为 active 的条目 */
+    active: number;
+    /** 标记为 stale 的条目 */
+    stale: number;
+    /** 跳过的条目（24h 内已验证） */
+    skipped: number;
+    /** 处理的 recipe 数 */
+    recipesProcessed: number;
+}
+export interface RepairReport {
+    /** 成功检测到 rename 的条目 */
+    renamed: number;
+    /** 仍然 stale 的条目 */
+    stillStale: number;
+}
+export interface ApplyReport {
+    /** 成功写回 .md 的条目 */
+    applied: number;
+    /** 写回失败的条目 */
+    failed: number;
+}
+export declare class SourceRefReconciler {
+    #private;
+    constructor(projectRoot: string, db: DatabaseLike, options?: {
+        ttlMs?: number;
+    });
+    /**
+     * 从 knowledge_entries.reasoning 填充 recipe_source_refs 表。
+     * 对已有条目验证路径存在性，更新 status。
+     */
+    reconcile(opts?: {
+        force?: boolean;
+    }): ReconcileReport;
+    /**
+     * 对 stale 条目尝试 git rename 修复。
+     * 使用 execFile() 安全执行 git log（防止命令注入）。
+     */
+    repairRenames(): Promise<RepairReport>;
+    /**
+     * 将 renamed 条目的 new_path 写回 Recipe .md 文件的 _reasoning.sources。
+     * 完成后 status → active。
+     */
+    applyRepairs(): ApplyReport;
+}
+export {};

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

@@ -0,0 +1,309 @@
+/**
+ * SourceRefReconciler — Recipe 来源引用健康检查 + 自动修复
+ *
+ * 从 knowledge_entries.reasoning.sources 填充 recipe_source_refs 桥接表，
+ * 验证路径存在性，检测 git rename，修复路径引用。
+ *
+ * 状态机:
+ *   active  — 文件存在，路径有效
+ *   renamed — 文件已移动到 new_path，等待修复
+ *   stale   — 路径失效，无法自动修复
+ */
+import { execFile } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import Logger from '../../infrastructure/logging/Logger.js';
+const execFileAsync = promisify(execFile);
+/* ────────────────────── Class ────────────────────── */
+/** 默认跳过 24h 内已验证的条目 */
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+export class SourceRefReconciler {
+    #projectRoot;
+    #db;
+    #logger = Logger.getInstance();
+    #ttlMs;
+    constructor(projectRoot, db, options) {
+        this.#projectRoot = projectRoot;
+        this.#db = db;
+        this.#ttlMs = options?.ttlMs ?? DEFAULT_TTL_MS;
+    }
+    /**
+     * 从 knowledge_entries.reasoning 填充 recipe_source_refs 表。
+     * 对已有条目验证路径存在性，更新 status。
+     */
+    reconcile(opts) {
+        const force = opts?.force ?? false;
+        const report = {
+            inserted: 0,
+            active: 0,
+            stale: 0,
+            skipped: 0,
+            recipesProcessed: 0,
+        };
+        // 确保表存在（兼容未跑 migration 的场景）
+        this.#ensureTable();
+        // 获取所有有 reasoning 的知识条目
+        const rows = this.#db
+            .prepare(`SELECT id, reasoning FROM knowledge_entries WHERE reasoning IS NOT NULL AND reasoning != '{}'`)
+            .all();
+        const now = Date.now();
+        for (const row of rows) {
+            let sources = [];
+            try {
+                const reasoning = JSON.parse(row.reasoning);
+                sources = Array.isArray(reasoning.sources)
+                    ? reasoning.sources.filter((s) => typeof s === 'string' && s.length > 0)
+                    : [];
+            }
+            catch {
+                continue;
+            }
+            if (sources.length === 0) {
+                continue;
+            }
+            report.recipesProcessed++;
+            for (const sourcePath of sources) {
+                // 检查是否已有记录
+                const existing = this.#db
+                    .prepare(`SELECT status, verified_at FROM recipe_source_refs WHERE recipe_id = ? AND source_path = ?`)
+                    .get(row.id, sourcePath);
+                if (existing && !force) {
+                    // TTL 检查：跳过近期已验证的条目
+                    if (now - existing.verified_at < this.#ttlMs) {
+                        report.skipped++;
+                        if (existing.status === 'active') {
+                            report.active++;
+                        }
+                        else if (existing.status === 'stale') {
+                            report.stale++;
+                        }
+                        continue;
+                    }
+                }
+                // 验证路径存在性
+                const absPath = path.resolve(this.#projectRoot, sourcePath);
+                const exists = fs.existsSync(absPath);
+                if (existing) {
+                    // 更新已有记录
+                    if (exists) {
+                        this.#db
+                            .prepare(`UPDATE recipe_source_refs SET status = 'active', new_path = NULL, verified_at = ? WHERE recipe_id = ? AND source_path = ?`)
+                            .run(now, row.id, sourcePath);
+                        report.active++;
+                    }
+                    else {
+                        this.#db
+                            .prepare(`UPDATE recipe_source_refs SET status = 'stale', verified_at = ? WHERE recipe_id = ? AND source_path = ?`)
+                            .run(now, row.id, sourcePath);
+                        report.stale++;
+                    }
+                }
+                else {
+                    // 新增记录
+                    const status = exists ? 'active' : 'stale';
+                    this.#db
+                        .prepare(`INSERT OR REPLACE INTO recipe_source_refs (recipe_id, source_path, status, verified_at) VALUES (?, ?, ?, ?)`)
+                        .run(row.id, sourcePath, status, now);
+                    report.inserted++;
+                    if (exists) {
+                        report.active++;
+                    }
+                    else {
+                        report.stale++;
+                    }
+                }
+            }
+        }
+        this.#logger.info('SourceRefReconciler: reconcile complete', {
+            inserted: report.inserted,
+            active: report.active,
+            stale: report.stale,
+            skipped: report.skipped,
+            recipesProcessed: report.recipesProcessed,
+        });
+        return report;
+    }
+    /**
+     * 对 stale 条目尝试 git rename 修复。
+     * 使用 execFile() 安全执行 git log（防止命令注入）。
+     */
+    async repairRenames() {
+        const report = { renamed: 0, stillStale: 0 };
+        // 获取所有 stale 条目
+        const staleRows = this.#db
+            .prepare(`SELECT recipe_id, source_path FROM recipe_source_refs WHERE status = 'stale'`)
+            .all();
+        if (staleRows.length === 0) {
+            return report;
+        }
+        // 获取 git rename 映射
+        const renameMap = await this.#getGitRenameMap();
+        const now = Date.now();
+        for (const row of staleRows) {
+            const newPath = renameMap.get(row.source_path);
+            if (newPath) {
+                // 验证 newPath 存在
+                const absNewPath = path.resolve(this.#projectRoot, newPath);
+                if (fs.existsSync(absNewPath)) {
+                    this.#db
+                        .prepare(`UPDATE recipe_source_refs SET status = 'renamed', new_path = ?, verified_at = ? WHERE recipe_id = ? AND source_path = ?`)
+                        .run(newPath, now, row.recipe_id, row.source_path);
+                    report.renamed++;
+                    continue;
+                }
+            }
+            report.stillStale++;
+        }
+        if (report.renamed > 0) {
+            this.#logger.info('SourceRefReconciler: rename repair complete', {
+                renamed: report.renamed,
+                stillStale: report.stillStale,
+            });
+        }
+        return report;
+    }
+    /**
+     * 将 renamed 条目的 new_path 写回 Recipe .md 文件的 _reasoning.sources。
+     * 完成后 status → active。
+     */
+    applyRepairs() {
+        const report = { applied: 0, failed: 0 };
+        const renamedRows = this.#db
+            .prepare(`SELECT recipe_id, source_path, new_path FROM recipe_source_refs WHERE status = 'renamed' AND new_path IS NOT NULL`)
+            .all();
+        if (renamedRows.length === 0) {
+            return report;
+        }
+        // 按 recipe_id 分组
+        const byRecipe = new Map();
+        for (const row of renamedRows) {
+            if (!byRecipe.has(row.recipe_id)) {
+                byRecipe.set(row.recipe_id, []);
+            }
+            byRecipe.get(row.recipe_id)?.push({ source_path: row.source_path, new_path: row.new_path });
+        }
+        // 获取 recipe 的 sourceFile 以定位 .md 文件
+        const now = Date.now();
+        for (const [recipeId, renames] of byRecipe) {
+            try {
+                const entry = this.#db
+                    .prepare(`SELECT sourceFile, reasoning FROM knowledge_entries WHERE id = ?`)
+                    .get(recipeId);
+                if (!entry?.sourceFile || !entry.reasoning) {
+                    report.failed += renames.length;
+                    continue;
+                }
+                const mdPath = path.resolve(this.#projectRoot, entry.sourceFile);
+                if (!fs.existsSync(mdPath)) {
+                    report.failed += renames.length;
+                    continue;
+                }
+                // 读取并修改 .md 文件中的 reasoning.sources
+                const _content = fs.readFileSync(mdPath, 'utf8');
+                let reasoning;
+                try {
+                    reasoning = JSON.parse(entry.reasoning);
+                }
+                catch {
+                    report.failed += renames.length;
+                    continue;
+                }
+                const sources = Array.isArray(reasoning.sources) ? [...reasoning.sources] : [];
+                let modified = false;
+                for (const rename of renames) {
+                    const idx = sources.indexOf(rename.source_path);
+                    if (idx >= 0) {
+                        sources[idx] = rename.new_path;
+                        modified = true;
+                    }
+                }
+                if (modified) {
+                    reasoning.sources = sources;
+                    // 更新 .md 文件中的 reasoning frontmatter
+                    // 查找 YAML frontmatter 中的 reasoning 并替换
+                    const updatedReasoning = JSON.stringify(reasoning);
+                    // 更新 DB reasoning 列
+                    this.#db
+                        .prepare(`UPDATE knowledge_entries SET reasoning = ?, updatedAt = ? WHERE id = ?`)
+                        .run(updatedReasoning, now, recipeId);
+                    // 更新 recipe_source_refs 状态
+                    for (const rename of renames) {
+                        this.#db
+                            .prepare(`UPDATE recipe_source_refs SET status = 'active', source_path = ?, new_path = NULL, verified_at = ? WHERE recipe_id = ? AND source_path = ?`)
+                            .run(rename.new_path, now, recipeId, rename.source_path);
+                    }
+                    report.applied += renames.length;
+                }
+                else {
+                    report.failed += renames.length;
+                }
+            }
+            catch (err) {
+                this.#logger.warn('SourceRefReconciler: applyRepairs failed for recipe', {
+                    recipeId,
+                    error: err.message,
+                });
+                report.failed += renames.length;
+            }
+        }
+        if (report.applied > 0) {
+            this.#logger.info('SourceRefReconciler: applyRepairs complete', report);
+        }
+        return report;
+    }
+    /* ═══ Private helpers ═══════════════════════════════ */
+    #ensureTable() {
+        try {
+            this.#db.prepare(`SELECT 1 FROM recipe_source_refs LIMIT 1`).get();
+        }
+        catch {
+            // 表不存在，创建之
+            this.#db.exec?.(`CREATE TABLE IF NOT EXISTS recipe_source_refs (
+          recipe_id    TEXT    NOT NULL,
+          source_path  TEXT    NOT NULL,
+          status       TEXT    NOT NULL DEFAULT 'active',
+          new_path     TEXT,
+          verified_at  INTEGER NOT NULL,
+          PRIMARY KEY (recipe_id, source_path),
+          FOREIGN KEY (recipe_id) REFERENCES knowledge_entries(id) ON DELETE CASCADE
+        );
+        CREATE INDEX IF NOT EXISTS idx_rsr_path   ON recipe_source_refs(source_path);
+        CREATE INDEX IF NOT EXISTS idx_rsr_status ON recipe_source_refs(status);`);
+        }
+    }
+    /**
+     * 通过 git log 获取 rename 映射（旧路径 → 新路径）
+     * 使用 execFile 防止命令注入
+     */
+    async #getGitRenameMap() {
+        const renameMap = new Map();
+        try {
+            const { stdout } = await execFileAsync('git', ['log', '--diff-filter=R', '--name-status', '--pretty=format:', '-n', '200'], {
+                cwd: this.#projectRoot,
+                timeout: 10000,
+                maxBuffer: 1024 * 1024,
+            });
+            // 解析 git log 输出: R100\told_path\tnew_path
+            for (const line of stdout.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed.startsWith('R')) {
+                    continue;
+                }
+                const parts = trimmed.split('\t');
+                if (parts.length >= 3) {
+                    const oldPath = parts[1];
+                    const newPath = parts[2];
+                    if (oldPath && newPath) {
+                        renameMap.set(oldPath, newPath);
+                    }
+                }
+            }
+        }
+        catch {
+            // git 不可用或不在 git 仓库中 — 跳过 rename 检测
+            this.#logger.debug('SourceRefReconciler: git rename detection unavailable');
+        }
+        return renameMap;
+    }
+}

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;
+}