autosnippet 2.8.3 → 2.10.0

package/lib/service/guard/GuardCheckEngine.js

@@ -237,18 +237,33 @@ export class GuardCheckEngine {
   getRules(language = null) {
     let rules = [];
 
-    // 从数据库加载自定义规则（kind='rule' 的 Recipe，覆盖 code-standard/code-style/best-practice/boundary-constraint）
+    // 从数据库加载自定义规则
+    // 优先从 knowledge_entries 表查询（V3），回退到 recipes 表（V2）
     try {
       const now = Date.now();
       if (!this._customRulesCache || now - this._cacheTime > this._cacheTTL) {
-        const rows = this.db.prepare(
-          `SELECT id, title, description, language, scope, constraints_json
-           FROM recipes WHERE (kind = 'rule' OR knowledge_type = 'boundary-constraint') AND status = 'active'`
-        ).all();
+        let rows = [];
+        try {
+          // V3: knowledge_entries 表
+          rows = this.db.prepare(
+            `SELECT id, title, description, language, scope, constraints
+             FROM knowledge_entries
+             WHERE (kind = 'rule' OR knowledge_type = 'boundary-constraint')
+               AND lifecycle = 'active'`
+          ).all();
+        } catch {
+          // V3 表不存在，回退到 V2 recipes 表
+          try {
+            rows = this.db.prepare(
+              `SELECT id, title, description, language, scope, constraints_json AS constraints
+               FROM recipes WHERE (kind = 'rule' OR knowledge_type = 'boundary-constraint') AND status = 'active'`
+            ).all();
+          } catch { /* neither table exists */ }
+        }
         this._customRulesCache = rows.map(r => {
           let guards = [];
           try {
-            const constraints = JSON.parse(r.constraints_json || '{}');
+            const constraints = JSON.parse(r.constraints || '{}');
             guards = constraints.guards || [];
           } catch { /* ignore */ }
           // Each guard entry becomes a rule
@@ -267,7 +282,7 @@ export class GuardCheckEngine {
       }
       rules.push(...this._customRulesCache);
     } catch {
-      // recipes table or knowledge_type column may not exist
+      // table or column may not exist
     }
 
     // 合并内置规则（不覆盖同名数据库规则）
@@ -377,9 +392,22 @@ export class GuardCheckEngine {
         hitMap.set(v.ruleId, count + 1);
       }
 
-      const updateStmt = this.db.prepare(
-        `UPDATE recipes SET guard_hit_count = guard_hit_count + ?, updated_at = ? WHERE id = ?`
-      );
+      // V3: guard_hit_count 已合并到 stats JSON，使用 json_set 更新
+      let updateStmt;
+      try {
+        updateStmt = this.db.prepare(
+          `UPDATE knowledge_entries
+           SET stats = json_set(COALESCE(stats, '{}'), '$.guard_hits',
+                 COALESCE(json_extract(stats, '$.guard_hits'), 0) + ?),
+               updated_at = ?
+           WHERE id = ?`
+        );
+      } catch {
+        // V3 表不存在，回退到 V2
+        updateStmt = this.db.prepare(
+          `UPDATE recipes SET guard_hit_count = guard_hit_count + ?, updated_at = ? WHERE id = ?`
+        );
+      }
       const now = Math.floor(Date.now() / 1000);
 
       for (const [ruleId, count] of hitMap) {
@@ -464,6 +492,9 @@ export class GuardCheckEngine {
 
   /**
    * 批量文件审计
+   * @param {Array<{path: string, content: string}>} files
+   * @param {object} options - {scope: 'file'|'target'|'project'}
+   * @returns {{files, summary, crossFileViolations}}
    */
   auditFiles(files, options = {}) {
     const results = [];
@@ -477,8 +508,14 @@ export class GuardCheckEngine {
       totalErrors += result.summary.errors;
     }
 
+    // ── 跨文件检查 ──
+    const crossFileViolations = this._runCrossFileChecks(files);
+    totalViolations += crossFileViolations.length;
+    totalErrors += crossFileViolations.filter(v => v.severity === 'error').length;
+
     return {
       files: results,
+      crossFileViolations,
       summary: {
         filesChecked: results.length,
         totalViolations,
@@ -488,6 +525,73 @@ export class GuardCheckEngine {
     };
   }
 
+  /**
+   * 跨文件检查 — 需要多文件上下文才能发现的问题
+   * @param {Array<{path: string, content: string}>} files
+   * @returns {Array<{ruleId, message, severity, locations}>}
+   */
+  _runCrossFileChecks(files) {
+    const violations = [];
+
+    // ── ObjC Category 跨文件重名检查 ──
+    // 收集所有文件中的 @interface ClassName(CategoryName) 声明
+    const categoryMap = new Map(); // key: "ClassName(CategoryName)" → [{filePath, line, snippet}]
+    const categoryRegex = /@interface\s+(\w+)\s*\(\s*(\w+)\s*\)/g;
+
+    for (const { path: filePath, content } of files) {
+      const ext = filePath.split('.').pop()?.toLowerCase();
+      if (ext !== 'm' && ext !== 'mm' && ext !== 'h') continue;
+
+      const lines = content.split(/\r?\n/);
+      for (let i = 0; i < lines.length; i++) {
+        categoryRegex.lastIndex = 0;
+        let m;
+        while ((m = categoryRegex.exec(lines[i])) !== null) {
+          const key = `${m[1]}(${m[2]})`;
+          if (!categoryMap.has(key)) categoryMap.set(key, []);
+          categoryMap.get(key).push({
+            filePath,
+            line: i + 1,
+            snippet: lines[i].trim().slice(0, 120),
+          });
+        }
+      }
+    }
+
+    // .h 和 .m 成对出现是正常的（声明 + 实现），只有同类型文件重名才是问题
+    // 或者超过 2 处声明就一定有问题
+    for (const [key, locations] of categoryMap) {
+      if (locations.length <= 1) continue;
+
+      // 按文件扩展名分组: .h 和 .m/.mm 各一个是合法的
+      const hFiles = locations.filter(l => l.filePath.endsWith('.h'));
+      const mFiles = locations.filter(l => !l.filePath.endsWith('.h'));
+
+      // 同类型文件中有多个声明 → 重名冲突
+      const hasDuplicateH = hFiles.length > 1;
+      const hasDuplicateM = mFiles.length > 1;
+      // 超过 2 处总声明（如 3 个文件都声明了同一个 Category）→ 一定有问题
+      const tooMany = locations.length > 2;
+
+      if (hasDuplicateH || hasDuplicateM || tooMany) {
+        // 收集冲突的那些位置
+        const conflictLocations = tooMany ? locations
+          : hasDuplicateH && hasDuplicateM ? locations
+          : hasDuplicateH ? hFiles
+          : mFiles;
+
+        violations.push({
+          ruleId: 'objc-cross-file-duplicate-category',
+          message: `Category ${key} 在 ${conflictLocations.length} 个文件中重复声明，可能导致方法覆盖或未定义行为`,
+          severity: 'warning',
+          locations: conflictLocations,
+        });
+      }
+    }
+
+    return violations;
+  }
+
   /**
    * 清除规则缓存
    */

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' + knowledge_type='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, knowledge_type=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',
+        knowledge_type: 'boundary-constraint',
         content: {
           pattern: data.pattern || '',
           rationale: data.note || data.sourceReason || '',
@@ -38,7 +42,7 @@ export class GuardService {
         constraints: {
           boundaries: [],
           preconditions: [],
-          sideEffects: [],
+          side_effects: [],
           guards: [{
             pattern: data.pattern,
             severity: data.severity || 'warning',
@@ -46,18 +50,18 @@ export class GuardService {
           }],
         },
         tags: data.languages || [],
-        status: RecipeStatus.ACTIVE,
-        createdBy: context.userId,
+        lifecycle: 'active',
+        created_by: 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',
+        rejection_reason: 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' + knowledge_type='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', knowledge_type: '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.knowledge_type === '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;