autosnippet 2.9.0 → 2.11.0

package/lib/service/guard/GuardService.js

@@ -1,36 +1,40 @@
-import { Recipe, RecipeStatus, KnowledgeType } from '../../domain/index.js';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { ValidationError, ConflictError, NotFoundError } from '../../shared/errors/index.js';
 import { v4 as uuidv4 } from 'uuid';
 
 /**
  * GuardService
- * 管理 Guard 约束规则的生命周期（现在统一存储在 Recipe 实体中）
- * Guard 规则 = knowledgeType: 'boundary-constraint' 的 Recipe，
+ * 管理 Guard 约束规则的生命周期 (V3: 使用 KnowledgeEntry / knowledgeRepository)
+ * Guard 规则 = kind='rule' + knowledgeType='boundary-constraint' 的 KnowledgeEntry,
  * 具体 pattern 存在 constraints.guards[] 里
  */
 export class GuardService {
-  constructor(recipeRepository, auditLogger, gateway) {
-    this.recipeRepository = recipeRepository;
+  /**
+   * @param {import('../../domain/knowledge/KnowledgeRepository.js').KnowledgeRepository} knowledgeRepository
+   */
+  constructor(knowledgeRepository, auditLogger, gateway) {
+    this.knowledgeRepository = knowledgeRepository;
     this.auditLogger = auditLogger;
     this.gateway = gateway;
     this.logger = Logger.getInstance();
   }
 
   /**
-   * 创建新规则 → 创建一个 knowledgeType=boundary-constraint 的 Recipe
+   * 创建新规则 → 创建一个 kind=rule, knowledgeType=boundary-constraint 的 KnowledgeEntry
    */
   async createRule(data, context) {
     try {
       this._validateCreateInput(data);
 
-      const recipe = new Recipe({
+      const { KnowledgeEntry } = await import('../../domain/knowledge/KnowledgeEntry.js');
+      const entry = KnowledgeEntry.fromJSON({
         id: uuidv4(),
         title: data.name,
         description: data.description,
         language: (data.languages || [])[0] || '',
         category: data.category || 'guard',
-        knowledgeType: KnowledgeType.BOUNDARY_CONSTRAINT,
+        kind: 'rule',
+        knowledgeType: 'boundary-constraint',
         content: {
           pattern: data.pattern || '',
           rationale: data.note || data.sourceReason || '',
@@ -46,18 +50,18 @@ export class GuardService {
           }],
         },
         tags: data.languages || [],
-        status: RecipeStatus.ACTIVE,
+        lifecycle: 'active',
         createdBy: context.userId,
       });
 
-      const created = await this.recipeRepository.create(recipe);
+      const created = await this.knowledgeRepository.create(entry);
 
       await this.auditLogger.log({
         action: 'create_guard_rule',
-        resourceType: 'recipe',
+        resourceType: 'knowledge_entry',
         resourceId: created.id,
         actor: context.userId,
-        details: `Created guard recipe: ${data.name}`,
+        details: `Created guard rule: ${data.name}`,
         timestamp: Math.floor(Date.now() / 1000),
       });
 
@@ -69,28 +73,28 @@ export class GuardService {
   }
 
   /**
-   * 启用规则（将 Recipe 状态设为 ACTIVE）
+   * 启用规则（将 lifecycle 设为 active）
    */
   async enableRule(ruleId, context) {
     try {
-      const recipe = await this.recipeRepository.findById(ruleId);
-      if (!recipe) throw new NotFoundError('Guard recipe not found', 'recipe', ruleId);
-      if (recipe.status === RecipeStatus.ACTIVE) {
+      const entry = await this.knowledgeRepository.findById(ruleId);
+      if (!entry) throw new NotFoundError('Guard rule not found', 'knowledge_entry', ruleId);
+      if (entry.lifecycle === 'active') {
         throw new ConflictError('Rule is already enabled', 'Cannot enable an already enabled rule');
       }
 
-      await this.recipeRepository.update(ruleId, { status: RecipeStatus.ACTIVE });
+      await this.knowledgeRepository.update(ruleId, { lifecycle: 'active' });
 
       await this.auditLogger.log({
         action: 'enable_guard_rule',
-        resourceType: 'recipe',
+        resourceType: 'knowledge_entry',
         resourceId: ruleId,
         actor: context.userId,
-        details: `Enabled guard recipe: ${recipe.title}`,
+        details: `Enabled guard rule: ${entry.title}`,
         timestamp: Math.floor(Date.now() / 1000),
       });
 
-      return this.recipeRepository.findById(ruleId);
+      return this.knowledgeRepository.findById(ruleId);
     } catch (error) {
       this.logger.error('Error enabling guard rule', { ruleId, error: error.message });
       throw error;
@@ -98,13 +102,13 @@ export class GuardService {
   }
 
   /**
-   * 禁用规则（将 Recipe 状态设为 DEPRECATED）
+   * 禁用规则（将 lifecycle 设为 deprecated）
    */
   async disableRule(ruleId, reason, context) {
     try {
-      const recipe = await this.recipeRepository.findById(ruleId);
-      if (!recipe) throw new NotFoundError('Guard recipe not found', 'recipe', ruleId);
-      if (recipe.status === RecipeStatus.DEPRECATED) {
+      const entry = await this.knowledgeRepository.findById(ruleId);
+      if (!entry) throw new NotFoundError('Guard rule not found', 'knowledge_entry', ruleId);
+      if (entry.lifecycle === 'deprecated') {
         throw new ConflictError('Rule is already disabled', 'Cannot disable an already disabled rule');
       }
 
@@ -112,22 +116,21 @@ export class GuardService {
         throw new ValidationError('Disable reason is required');
       }
 
-      await this.recipeRepository.update(ruleId, {
-        status: RecipeStatus.DEPRECATED,
-        deprecation_reason: reason,
-        deprecated_at: Math.floor(Date.now() / 1000),
+      await this.knowledgeRepository.update(ruleId, {
+        lifecycle: 'deprecated',
+        rejectionReason: reason,
       });
 
       await this.auditLogger.log({
         action: 'disable_guard_rule',
-        resourceType: 'recipe',
+        resourceType: 'knowledge_entry',
         resourceId: ruleId,
         actor: context.userId,
-        details: `Disabled guard recipe: ${reason}`,
+        details: `Disabled guard rule: ${reason}`,
         timestamp: Math.floor(Date.now() / 1000),
       });
 
-      return this.recipeRepository.findById(ruleId);
+      return this.knowledgeRepository.findById(ruleId);
     } catch (error) {
       this.logger.error('Error disabling guard rule', { ruleId, error: error.message });
       throw error;
@@ -136,6 +139,7 @@ export class GuardService {
 
   /**
    * 检查代码是否匹配 Guard 规则
+   * 查询所有 active 的 rule 实体的 constraints.guards[]
    */
   async checkCode(code, options = {}) {
     try {
@@ -145,19 +149,27 @@ export class GuardService {
 
       const { language = null } = options;
 
-      // 获取所有包含 guards 的 active Recipe
-      const guardRecipes = await this.recipeRepository.findWithGuards(language);
+      // V3: 使用 findActiveRules() 查询 kind='rule' + lifecycle='active'
+      let guardEntries = await this.knowledgeRepository.findActiveRules();
+
+      // 按语言过滤
+      if (language) {
+        guardEntries = guardEntries.filter(
+          e => !e.language || e.language === language
+        );
+      }
 
       const matches = [];
-      for (const recipe of guardRecipes) {
-        for (const guard of (recipe.constraints?.guards || [])) {
+      for (const entry of guardEntries) {
+        const guards = entry.constraints?.guards || [];
+        for (const guard of guards) {
           try {
             const regex = new RegExp(guard.pattern, 'gm');
             const codeMatches = [...code.matchAll(regex)];
             if (codeMatches.length > 0) {
               matches.push({
-                ruleId: recipe.id,
-                ruleName: recipe.title,
+                ruleId: entry.id,
+                ruleName: entry.title,
                 severity: guard.severity || 'warning',
                 message: guard.message || '',
                 matches: codeMatches.map(m => ({
@@ -169,7 +181,7 @@ export class GuardService {
               });
             }
           } catch (e) {
-            this.logger.warn('Error matching guard pattern', { recipeId: recipe.id, error: e.message });
+            this.logger.warn('Error matching guard pattern', { entryId: entry.id, error: e.message });
           }
         }
       }
@@ -182,13 +194,14 @@ export class GuardService {
   }
 
   /**
-   * 查询规则列表（boundary-constraint Recipes）
+   * 查询规则列表 (kind='rule' + knowledgeType='boundary-constraint')
    */
   async listRules(filters = {}, pagination = {}) {
     try {
       const { page = 1, pageSize = 20 } = pagination;
-      return this.recipeRepository.findByKnowledgeType(
-        KnowledgeType.BOUNDARY_CONSTRAINT, { page, pageSize }
+      return this.knowledgeRepository.findWithPagination(
+        { kind: 'rule', knowledgeType: 'boundary-constraint' },
+        { page, pageSize }
       );
     } catch (error) {
       this.logger.error('Error listing rules', { error: error.message, filters });
@@ -202,10 +215,9 @@ export class GuardService {
   async searchRules(keyword, pagination = {}) {
     try {
       const { page = 1, pageSize = 20 } = pagination;
-      // 搜索所有 Recipes 然后过滤 boundary-constraint
-      const result = await this.recipeRepository.search(keyword, { page, pageSize });
+      const result = await this.knowledgeRepository.search(keyword, { page, pageSize });
       result.data = (result.data || []).filter(
-        r => r.knowledgeType === KnowledgeType.BOUNDARY_CONSTRAINT
+        r => r.kind === 'rule' && r.knowledgeType === 'boundary-constraint'
       );
       result.total = result.data.length;
       return result;
@@ -220,8 +232,7 @@ export class GuardService {
    */
   async getRuleStats() {
     try {
-      // 基于 recipes 表的 boundary-constraint 统计
-      return this.recipeRepository.getStats();
+      return this.knowledgeRepository.getStats();
     } catch (error) {
       this.logger.error('Error getting rule stats', { error: error.message });
       throw error;

package/lib/service/knowledge/ConfidenceRouter.js

@@ -0,0 +1,159 @@
+import Logger from '../../infrastructure/logging/Logger.js';
+
+/**
+ * ConfidenceRouter — 知识条目自动审核路由器
+ *
+ * 根据 KnowledgeEntry 的 reasoning.confidence、质量评分、
+ * 内容完整性等信号判断是否可自动审核通过。
+ *
+ * 路由结果:
+ *   auto_approve — 置信度高、内容完整，自动通过 + fastTrack
+ *   pending      — 需要人工审核
+ *   reject       — 置信度过低或不满足基本要求
+ */
+
+const DEFAULT_CONFIG = {
+  /** 自动通过的最低 confidence 阈值 */
+  autoApproveThreshold: 0.85,
+  /** 自动驳回的 confidence 阈值 */
+  rejectThreshold: 0.2,
+  /** 需要的最少内容字符数 */
+  minContentLength: 20,
+  /** 自动通过要求 reasoning.isValid() */
+  requireReasoning: true,
+  /** 来源白名单（这些来源可以适用更宽松的阈值） */
+  trustedSources: ['bootstrap', 'cursor-scan'],
+  /** 可信来源的自动通过阈值 */
+  trustedAutoApproveThreshold: 0.7,
+};
+
+export class ConfidenceRouter {
+  /**
+   * @param {Object} [config] - 路由配置
+   * @param {import('../quality/QualityScorer.js').QualityScorer} [qualityScorer]
+   */
+  constructor(config = {}, qualityScorer = null) {
+    this._config = { ...DEFAULT_CONFIG, ...config };
+    this._qualityScorer = qualityScorer;
+    this.logger = Logger.getInstance();
+  }
+
+  /**
+   * 路由决策
+   * @param {import('../../domain/knowledge/KnowledgeEntry.js').KnowledgeEntry} entry
+   * @returns {Promise<{ action: 'auto_approve'|'pending'|'reject', reason: string, confidence?: number }>}
+   */
+  async route(entry) {
+    const confidence = entry.reasoning?.confidence ?? 0;
+    const source = entry.source || 'manual';
+    const isTrusted = this._config.trustedSources.includes(source);
+
+    // ── 阶段 1: 基本过滤 — 内容不完整直接 pending ──
+    if (!entry.isValid()) {
+      return {
+        action: 'pending',
+        reason: 'Content incomplete (title or content missing)',
+        confidence,
+      };
+    }
+
+    // ── 阶段 2: 低置信度驳回 ──
+    if (confidence < this._config.rejectThreshold && confidence > 0) {
+      return {
+        action: 'reject',
+        reason: `Confidence too low: ${confidence.toFixed(2)} < ${this._config.rejectThreshold}`,
+        confidence,
+      };
+    }
+
+    // ── 阶段 3: 内容最短长度检查 ──
+    const contentLength = this._estimateContentLength(entry);
+    if (contentLength < this._config.minContentLength) {
+      return {
+        action: 'pending',
+        reason: `Content too short: ${contentLength} chars < ${this._config.minContentLength}`,
+        confidence,
+      };
+    }
+
+    // ── 阶段 4: Reasoning 检查 ──
+    if (this._config.requireReasoning && !entry.reasoning?.isValid?.()) {
+      // 无 reasoning 不驳回，但进入人工审核
+      return {
+        action: 'pending',
+        reason: 'Reasoning not provided or invalid',
+        confidence,
+      };
+    }
+
+    // ── 阶段 5: 质量评分（可选） ──
+    let qualityScore = null;
+    if (this._qualityScorer) {
+      try {
+        const scorerInput = {
+          title:      entry.title,
+          trigger:    entry.trigger,
+          code:       entry.content?.pattern || entry.content?.markdown || '',
+          language:   entry.language,
+          category:   entry.category,
+          summary:    entry.summaryCn || entry.summaryEn || '',
+          usageGuide: entry.usageGuideCn || entry.usageGuideEn || '',
+          headers:    entry.headers || [],
+          tags:       entry.tags || [],
+        };
+        const result = this._qualityScorer.score(scorerInput);
+        qualityScore = result.score;
+      } catch {
+        // 评分失败不阻塞路由
+      }
+    }
+
+    // ── 阶段 6: 自动通过判定 ──
+    const threshold = isTrusted
+      ? this._config.trustedAutoApproveThreshold
+      : this._config.autoApproveThreshold;
+
+    if (confidence >= threshold) {
+      // 如果有质量评分且太低，降级到 pending
+      if (qualityScore !== null && qualityScore < 0.3) {
+        return {
+          action: 'pending',
+          reason: `Confidence OK (${confidence.toFixed(2)}) but quality low (${qualityScore.toFixed(2)})`,
+          confidence,
+        };
+      }
+
+      return {
+        action: 'auto_approve',
+        reason: `Confidence ${confidence.toFixed(2)} >= threshold ${threshold} (source: ${source})`,
+        confidence,
+      };
+    }
+
+    // ── 默认: 需要人工审核 ──
+    return {
+      action: 'pending',
+      reason: `Confidence ${confidence.toFixed(2)} < threshold ${threshold}`,
+      confidence,
+    };
+  }
+
+  /**
+   * 估算内容长度
+   */
+  _estimateContentLength(entry) {
+    const content = entry.content;
+    if (!content) return 0;
+
+    const parts = [
+      content.pattern,
+      content.rationale,
+      content.markdown,
+      ...(content.steps || []).map(s => typeof s === 'string' ? s : s?.description || ''),
+    ].filter(Boolean);
+
+    return parts.reduce((sum, p) => sum + p.length, 0);
+  }
+}
+
+export default ConfidenceRouter;