autosnippet 3.3.6 → 3.3.8

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

@@ -87,20 +87,29 @@ export class ConfidenceRouter {
         let qualityScore = null;
         if (this._qualityScorer) {
             try {
+                const content = entry.content && typeof entry.content === 'object'
+                    ? entry.content
+                    : {};
+                const reasoning = entry.reasoning && typeof entry.reasoning === 'object'
+                    ? entry.reasoning
+                    : {};
                 const scorerInput = {
                     title: entry.title,
                     trigger: entry.trigger,
-                    code: entry.content?.pattern || entry.content?.markdown || '',
+                    description: entry.description || '',
                     language: entry.language,
                     category: entry.category,
-                    summary: entry.description ||
-                        entry.summaryCn ||
-                        entry.summaryEn ||
-                        '',
-                    usageGuide: entry.usageGuide ||
-                        entry.usageGuideCn ||
-                        entry.usageGuideEn ||
-                        '',
+                    doClause: entry.doClause || '',
+                    dontClause: entry.dontClause || '',
+                    whenClause: entry.whenClause || '',
+                    coreCode: entry.coreCode || '',
+                    usageGuide: entry.usageGuide || content.markdown || '',
+                    contentMarkdown: content.markdown || '',
+                    contentRationale: content.rationale || '',
+                    reasoningWhyStandard: reasoning.whyStandard || '',
+                    reasoningSources: reasoning.sources || [],
+                    reasoningConfidence: reasoning.confidence || 0,
+                    source: entry.source || '',
                     headers: entry.headers || [],
                     tags: entry.tags || [],
                 };

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

@@ -19,7 +19,8 @@
  */
 import type { KnowledgeEntry } from '../../domain/knowledge/KnowledgeEntry.js';
 import Logger from '../../infrastructure/logging/Logger.js';
-export declare class KnowledgeFileWriter {
+import type { KnowledgeFileStore } from '../../repository/knowledge/KnowledgeFileStore.js';
+export declare class KnowledgeFileWriter implements KnowledgeFileStore {
     candidatesDir: string;
     logger: ReturnType<typeof Logger.getInstance>;
     projectRoot: string;

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

@@ -4,68 +4,34 @@
  * 管理 Recipe 之间的关系（统一模型，包含所有知识类型）
  * 支持关系查询、路径分析、PageRank 权重计算
  */
-import type { Database } from 'better-sqlite3';
 import { RelationType } from '../../domain/index.js';
 import Logger from '../../infrastructure/logging/Logger.js';
-/** SQLite row from knowledge_edges table */
-interface EdgeRow {
-    id: number;
-    from_id: string;
-    from_type: string;
-    to_id: string;
-    to_type: string;
-    relation: string;
-    weight: number;
-    metadata_json: string;
-    created_at: number;
-    updated_at: number;
-}
-interface MappedEdge {
-    id: number;
-    fromId: string;
-    fromType: string;
-    toId: string;
-    toType: string;
-    relation: string;
-    weight: number;
-    metadata: Record<string, unknown>;
-    createdAt: number;
-    updatedAt: number;
-}
-interface DbLike {
-    getDb?: () => Database;
-    prepare(sql: string): {
-        run(...params: unknown[]): {
-            changes: number;
-        };
-        get(...params: unknown[]): EdgeRow;
-        all(...params: unknown[]): EdgeRow[];
-    };
-}
+import type { KnowledgeEdgeRepositoryImpl } from '../../repository/knowledge/KnowledgeEdgeRepository.js';
+type EdgeRepoLike = Pick<KnowledgeEdgeRepositoryImpl, 'upsertEdge' | 'removeEdge' | 'findOutgoing' | 'findIncoming' | 'findIncomingByRelations' | 'findByRelation' | 'findAll' | 'getStats'>;
 export { RelationType };
 export declare class KnowledgeGraphService {
-    db: DbLike;
+    #private;
     logger: ReturnType<typeof Logger.getInstance>;
-    constructor(db: DbLike);
+    constructor(edgeRepo: EdgeRepoLike);
     /** 添加关系边 */
-    addEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string, metadata?: Record<string, unknown>): {
+    addEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string, metadata?: Record<string, unknown>): Promise<{
         success: boolean;
         error?: undefined;
     } | {
         success: boolean;
         error: string;
-    };
+    }>;
     /** 删除关系边 */
-    removeEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string): void;
+    removeEdge(fromId: string, fromType: string, toId: string, toType: string, relation: string): Promise<void>;
     /** 查询某个节点的所有关系 */
-    getEdges(nodeId: string, nodeType: string, direction?: string): {
-        outgoing: MappedEdge[];
-        incoming: MappedEdge[];
-    };
+    getEdges(nodeId: string, nodeType: string, direction?: string): Promise<{
+        outgoing: import("../../repository/knowledge/KnowledgeEdgeRepository.js").KnowledgeEdge[];
+        incoming: import("../../repository/knowledge/KnowledgeEdgeRepository.js").KnowledgeEdge[];
+    }>;
     /** 查询指定关系类型的连接 */
-    getRelated(nodeId: string, nodeType: string, relation: string): MappedEdge[];
+    getRelated(nodeId: string, nodeType: string, relation: string): Promise<import("../../repository/knowledge/KnowledgeEdgeRepository.js").KnowledgeEdge[]>;
     /** 查找两个节点之间的路径 (BFS, 最大深度 5) */
-    findPath(fromId: string, fromType: string, toId: string, toType: string, maxDepth?: number): {
+    findPath(fromId: string, fromType: string, toId: string, toType: string, maxDepth?: number): Promise<{
         found: boolean;
         path: {
             from: {
@@ -79,26 +45,18 @@ export declare class KnowledgeGraphService {
             relation: string;
         }[];
         depth: number;
-    };
+    }>;
     /** 获取节点的影响范围（下游依赖分析） */
-    getImpactAnalysis(nodeId: string, nodeType: string, maxDepth?: number): any[];
+    getImpactAnalysis(nodeId: string, nodeType: string, maxDepth?: number): Promise<any[]>;
     /** 获取图谱整体统计 */
-    /** @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部 */
-    getStats(nodeType?: string): {
-        totalEdges: number;
-        byRelation: {
-            [k: string]: unknown;
-        };
-        nodeTypes: EdgeRow[];
-    };
+    getStats(nodeType?: string): Promise<import("../../repository/knowledge/KnowledgeEdgeRepository.js").EdgeStats>;
     /**
      * 获取全量边（供 Dashboard 图谱可视化）
      * @param [limit=500] 最大返回条数
      * @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
      */
-    getAllEdges(limit?: number, nodeType?: string): MappedEdge[];
-    _mapEdge(row: EdgeRow): MappedEdge;
+    getAllEdges(limit?: number, nodeType?: string): Promise<import("../../repository/knowledge/KnowledgeEdgeRepository.js").KnowledgeEdge[]>;
 }
-export declare function initKnowledgeGraphService(db: DbLike): KnowledgeGraphService;
+export declare function initKnowledgeGraphService(edgeRepo: EdgeRepoLike): KnowledgeGraphService;
 export declare function getKnowledgeGraphService(): KnowledgeGraphService | null;
 export default KnowledgeGraphService;

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

@@ -9,22 +9,24 @@ import Logger from '../../infrastructure/logging/Logger.js';
 // Re-export unified RelationType for backward compatibility
 export { RelationType };
 export class KnowledgeGraphService {
-    db;
+    #edgeRepo;
     logger;
-    constructor(db) {
-        this.db = typeof db?.getDb === 'function' ? db.getDb() : db;
+    constructor(edgeRepo) {
+        this.#edgeRepo = edgeRepo;
         this.logger = Logger.getInstance();
     }
     /** 添加关系边 */
-    addEdge(fromId, fromType, toId, toType, relation, metadata = {}) {
-        const now = Math.floor(Date.now() / 1000);
+    async addEdge(fromId, fromType, toId, toType, relation, metadata = {}) {
         try {
-            this.db
-                .prepare(`
-        INSERT OR REPLACE INTO knowledge_edges (from_id, from_type, to_id, to_type, relation, weight, metadata_json, created_at, updated_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-      `)
-                .run(fromId, fromType, toId, toType, relation, metadata.weight || 1.0, JSON.stringify(metadata), now, now);
+            await this.#edgeRepo.upsertEdge({
+                fromId,
+                fromType,
+                toId,
+                toType,
+                relation,
+                weight: metadata.weight || 1.0,
+                metadata,
+            });
             return { success: true };
         }
         catch (error) {
@@ -34,43 +36,25 @@ export class KnowledgeGraphService {
         }
     }
     /** 删除关系边 */
-    removeEdge(fromId, fromType, toId, toType, relation) {
-        this.db
-            .prepare(`
-      DELETE FROM knowledge_edges WHERE from_id = ? AND from_type = ? AND to_id = ? AND to_type = ? AND relation = ?
-    `)
-            .run(fromId, fromType, toId, toType, relation);
+    async removeEdge(fromId, fromType, toId, toType, relation) {
+        await this.#edgeRepo.removeEdge(fromId, fromType, toId, toType, relation);
     }
     /** 查询某个节点的所有关系 */
-    getEdges(nodeId, nodeType, direction = 'both') {
+    async getEdges(nodeId, nodeType, direction = 'both') {
         const outgoing = direction === 'both' || direction === 'out'
-            ? this.db
-                .prepare(`SELECT * FROM knowledge_edges WHERE from_id = ? AND from_type = ?`)
-                .all(nodeId, nodeType)
+            ? await this.#edgeRepo.findOutgoing(nodeId, nodeType)
             : [];
         const incoming = direction === 'both' || direction === 'in'
-            ? this.db
-                .prepare(`SELECT * FROM knowledge_edges WHERE to_id = ? AND to_type = ?`)
-                .all(nodeId, nodeType)
+            ? await this.#edgeRepo.findIncoming(nodeId, nodeType)
             : [];
-        return {
-            outgoing: outgoing.map((row) => this._mapEdge(row)),
-            incoming: incoming.map((row) => this._mapEdge(row)),
-        };
+        return { outgoing, incoming };
     }
     /** 查询指定关系类型的连接 */
-    getRelated(nodeId, nodeType, relation) {
-        const rows = this.db
-            .prepare(`
-      SELECT * FROM knowledge_edges WHERE from_id = ? AND from_type = ? AND relation = ?
-      UNION ALL
-      SELECT * FROM knowledge_edges WHERE to_id = ? AND to_type = ? AND relation = ?
-    `)
-            .all(nodeId, nodeType, relation, nodeId, nodeType, relation);
-        return rows.map((row) => this._mapEdge(row));
+    async getRelated(nodeId, nodeType, relation) {
+        return this.#edgeRepo.findByRelation(nodeId, nodeType, relation);
     }
     /** 查找两个节点之间的路径 (BFS, 最大深度 5) */
-    findPath(fromId, fromType, toId, toType, maxDepth = 5) {
+    async findPath(fromId, fromType, toId, toType, maxDepth = 5) {
         const visited = new Set();
         const queue = [
             {
@@ -80,7 +64,11 @@ export class KnowledgeGraphService {
             },
         ];
         while (queue.length > 0) {
-            const { id, type, path } = queue.shift();
+            const current = queue.shift();
+            if (!current) {
+                break;
+            }
+            const { id, type, path } = current;
             if (path.length >= maxDepth) {
                 continue;
             }
@@ -89,24 +77,20 @@ export class KnowledgeGraphService {
                 continue;
             }
             visited.add(key);
-            const neighbors = this.db
-                .prepare(`
-        SELECT to_id, to_type, relation, weight FROM knowledge_edges WHERE from_id = ? AND from_type = ?
-      `)
-                .all(id, type);
+            const neighbors = await this.#edgeRepo.findOutgoing(id, type);
             for (const neighbor of neighbors) {
                 const newPath = [
                     ...path,
                     {
                         from: { id, type },
-                        to: { id: neighbor.to_id, type: neighbor.to_type },
+                        to: { id: neighbor.toId, type: neighbor.toType },
                         relation: neighbor.relation,
                     },
                 ];
-                if (neighbor.to_id === toId && neighbor.to_type === toType) {
+                if (neighbor.toId === toId && neighbor.toType === toType) {
                     return { found: true, path: newPath, depth: newPath.length };
                 }
-                queue.push({ id: neighbor.to_id, type: neighbor.to_type, path: newPath });
+                queue.push({ id: neighbor.toId, type: neighbor.toType, path: newPath });
             }
         }
         return {
@@ -116,95 +100,60 @@ export class KnowledgeGraphService {
         };
     }
     /** 获取节点的影响范围（下游依赖分析） */
-    getImpactAnalysis(nodeId, nodeType, maxDepth = 3) {
+    async getImpactAnalysis(nodeId, nodeType, maxDepth = 3) {
+        const impactRelations = [
+            'requires',
+            'extends',
+            'enforces',
+            'depends_on',
+            'inherits',
+            'implements',
+            'calls',
+            'prerequisite',
+        ];
         const impacted = new Map();
         const queue = [{ id: nodeId, type: nodeType, depth: 0 }];
         while (queue.length > 0) {
-            const { id, type, depth } = queue.shift();
+            const current = queue.shift();
+            if (!current) {
+                break;
+            }
+            const { id, type, depth } = current;
             if (depth >= maxDepth) {
                 continue;
             }
-            const dependents = this.db
-                .prepare(`
-        SELECT from_id, from_type, relation FROM knowledge_edges 
-        WHERE to_id = ? AND to_type = ? AND relation IN ('requires', 'extends', 'enforces', 'depends_on', 'inherits', 'implements', 'calls', 'prerequisite')
-      `)
-                .all(id, type);
+            const dependents = await this.#edgeRepo.findIncomingByRelations(id, type, impactRelations);
             for (const dep of dependents) {
-                const key = `${dep.from_type}:${dep.from_id}`;
+                const key = `${dep.fromType}:${dep.fromId}`;
                 if (!impacted.has(key)) {
                     impacted.set(key, {
-                        id: dep.from_id,
-                        type: dep.from_type,
+                        id: dep.fromId,
+                        type: dep.fromType,
                         relation: dep.relation,
                         depth: depth + 1,
                     });
-                    queue.push({ id: dep.from_id, type: dep.from_type, depth: depth + 1 });
+                    queue.push({ id: dep.fromId, type: dep.fromType, depth: depth + 1 });
                 }
             }
         }
         return Array.from(impacted.values());
     }
     /** 获取图谱整体统计 */
-    /** @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部 */
-    getStats(nodeType) {
-        const typeFilter = nodeType
-            ? ` WHERE from_type = '${nodeType}' AND to_type = '${nodeType}'`
-            : '';
-        const edgeCount = this.db
-            .prepare(`SELECT COUNT(*) as total FROM knowledge_edges${typeFilter}`)
-            .get();
-        const byRelation = this.db
-            .prepare(`SELECT relation, COUNT(*) as count FROM knowledge_edges${typeFilter} GROUP BY relation`)
-            .all();
-        const byType = this.db
-            .prepare(`SELECT from_type as type, COUNT(DISTINCT from_id) as count FROM knowledge_edges${typeFilter} GROUP BY from_type
-       UNION
-       SELECT to_type as type, COUNT(DISTINCT to_id) as count FROM knowledge_edges${typeFilter} GROUP BY to_type`)
-            .all();
-        return {
-            totalEdges: edgeCount.total,
-            byRelation: Object.fromEntries(byRelation.map((r) => [r.relation, r.count])),
-            nodeTypes: byType,
-        };
+    async getStats(nodeType) {
+        return this.#edgeRepo.getStats(nodeType);
     }
     /**
      * 获取全量边（供 Dashboard 图谱可视化）
      * @param [limit=500] 最大返回条数
      * @param [nodeType] 过滤节点类型（如 'recipe'），为空则返回全部
      */
-    getAllEdges(limit = 500, nodeType) {
-        let sql, params;
-        if (nodeType) {
-            sql = `SELECT * FROM knowledge_edges WHERE from_type = ? AND to_type = ? ORDER BY updated_at DESC LIMIT ?`;
-            params = [nodeType, nodeType, limit];
-        }
-        else {
-            sql = `SELECT * FROM knowledge_edges ORDER BY updated_at DESC LIMIT ?`;
-            params = [limit];
-        }
-        const rows = this.db.prepare(sql).all(...params);
-        return rows.map((row) => this._mapEdge(row));
-    }
-    // Private
-    _mapEdge(row) {
-        return {
-            id: row.id,
-            fromId: row.from_id,
-            fromType: row.from_type,
-            toId: row.to_id,
-            toType: row.to_type,
-            relation: row.relation,
-            weight: row.weight,
-            metadata: JSON.parse(row.metadata_json || '{}'),
-            createdAt: row.created_at,
-            updatedAt: row.updated_at,
-        };
+    async getAllEdges(limit = 500, nodeType) {
+        return this.#edgeRepo.findAll({ nodeType, limit });
     }
 }
 let instance = null;
-export function initKnowledgeGraphService(db) {
-    instance = new KnowledgeGraphService(db);
+export function initKnowledgeGraphService(edgeRepo) {
+    instance = new KnowledgeGraphService(edgeRepo);
     return instance;
 }
 export function getKnowledgeGraphService() {

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

@@ -23,12 +23,21 @@ interface QualityScorerLike {
 interface EventBusLike {
     emit(event: string | symbol, ...args: unknown[]): boolean;
 }
+interface EdgeRepoLike {
+    deleteOutgoing(fromId: string, fromType: string): Promise<number>;
+    deleteByEntryId(entryId: string): Promise<number>;
+}
+interface ProposalRepoLike {
+    deleteByTargetRecipeId(targetRecipeId: string): number;
+}
 interface KnowledgeServiceOptions {
     fileWriter?: KnowledgeFileWriter | null;
     skillHooks?: SkillHooksLike | null;
     confidenceRouter?: ConfidenceRouter | null;
     qualityScorer?: QualityScorerLike | null;
     eventBus?: EventBusLike | null;
+    edgeRepo?: EdgeRepoLike | null;
+    proposalRepo?: ProposalRepoLike | null;
 }
 interface ServiceContext {
     userId: string;
@@ -59,9 +68,11 @@ interface PaginationOptions {
  */
 export declare class KnowledgeService {
     _confidenceRouter: ConfidenceRouter | null;
+    _edgeRepo: EdgeRepoLike | null;
     _eventBus: EventBusLike | null;
     _fileWriter: KnowledgeFileWriter | null;
     _knowledgeGraphService: KnowledgeGraphService | null;
+    _proposalRepo: ProposalRepoLike | null;
     _qualityScorer: QualityScorerLike | null;
     _skillHooks: SkillHooksLike | null;
     auditLogger: AuditLoggerLike;
@@ -166,7 +177,10 @@ export declare class KnowledgeService {
     _validateCreateInput(data: KnowledgeEntryProps): void;
     /**
      * 为 QualityScorer 适配输入
-     * QualityScorer 需要: title, trigger, code, language, category, summary, usageGuide, headers, tags
+     * QualityScorer v2 needs: title, trigger, description, language, category,
+     * doClause, dontClause, whenClause, coreCode, usageGuide,
+     * contentMarkdown, contentRationale, reasoningWhyStandard, reasoningSources,
+     * reasoningConfidence, source, headers, tags, views, clicks, rating
      */
     _adaptForScorer(entry: KnowledgeEntry): Record<string, unknown>;
     /**