autosnippet 2.9.0 → 2.11.0

package/lib/core/gateway/GatewayActionRegistry.js

@@ -17,133 +17,125 @@ const logger = Logger.getInstance();
  * @param {import('../../injection/ServiceContainer.js').ServiceContainer} container
  */
 export function registerGatewayActions(gateway, container) {
-  // ========== Candidate Actions ==========
+  // ========== Knowledge Actions (V3: replaces Candidate + Recipe) ==========
 
   gateway.register('candidate:create', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.createCandidate(ctx.data, {
+    const service = container.get('knowledgeService');
+    return service.create(ctx.data, {
       userId: ctx.actor,
-      ip: ctx.data._ip,
-      userAgent: ctx.data._userAgent,
     });
   });
 
   gateway.register('candidate:approve', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.approveCandidate(ctx.data.candidateId, {
+    const service = container.get('knowledgeService');
+    return service.approve(ctx.data.candidateId, {
       userId: ctx.actor,
     });
   });
 
   gateway.register('candidate:reject', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.rejectCandidate(ctx.data.candidateId, ctx.data.reason, {
+    const service = container.get('knowledgeService');
+    return service.reject(ctx.data.candidateId, ctx.data.reason, {
       userId: ctx.actor,
     });
   });
 
   gateway.register('candidate:apply_to_recipe', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.applyToRecipe(ctx.data.candidateId, ctx.data.recipeId, {
-      userId: ctx.actor,
-    });
+    const service = container.get('knowledgeService');
+    return service.publish(ctx.data.candidateId, { userId: ctx.actor });
   });
 
   gateway.register('candidate:list', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.listCandidates(ctx.data.filters, ctx.data.pagination);
+    const service = container.get('knowledgeService');
+    return service.list(ctx.data.filters, ctx.data.pagination);
   });
 
   gateway.register('candidate:search', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.searchCandidates(ctx.data.keyword, ctx.data.pagination);
+    const service = container.get('knowledgeService');
+    return service.search(ctx.data.keyword, ctx.data.pagination);
   });
 
   gateway.register('candidate:get_stats', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.getCandidateStats();
+    const service = container.get('knowledgeService');
+    return service.getStats();
   });
 
   gateway.register('candidate:get', async (ctx) => {
-    const repo = container.get('candidateRepository');
-    return repo.findById(ctx.data.id);
+    const service = container.get('knowledgeService');
+    return service.get(ctx.data.id);
   });
 
   gateway.register('candidate:delete', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.deleteCandidate(ctx.data.candidateId, { userId: ctx.actor });
+    const service = container.get('knowledgeService');
+    return service.delete(ctx.data.candidateId, { userId: ctx.actor });
   });
 
-  // ========== Recipe Actions ==========
+  // ========== Recipe Actions (V3: routed to knowledgeService) ==========
 
   gateway.register('recipe:create', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.createRecipe(ctx.data, {
+    const service = container.get('knowledgeService');
+    return service.create(ctx.data, {
       userId: ctx.actor,
-      ip: ctx.data._ip,
-      userAgent: ctx.data._userAgent,
     });
   });
 
   gateway.register('recipe:publish', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.publishRecipe(ctx.data.recipeId, {
+    const service = container.get('knowledgeService');
+    return service.publish(ctx.data.recipeId, {
       userId: ctx.actor,
     });
   });
 
   gateway.register('recipe:deprecate', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.deprecateRecipe(ctx.data.recipeId, ctx.data.reason, {
+    const service = container.get('knowledgeService');
+    return service.deprecate(ctx.data.recipeId, ctx.data.reason, {
       userId: ctx.actor,
     });
   });
 
   gateway.register('recipe:update_quality', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.updateQuality(ctx.data.recipeId, ctx.data.metrics, {
-      userId: ctx.actor,
-    });
+    const service = container.get('knowledgeService');
+    return service.updateQuality(ctx.data.recipeId, ctx.data.metrics);
   });
 
   gateway.register('recipe:adopt', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.incrementAdoption(ctx.data.recipeId);
+    const service = container.get('knowledgeService');
+    return service.incrementUsage(ctx.data.recipeId, 'adoption');
   });
 
   gateway.register('recipe:apply', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.incrementApplication(ctx.data.recipeId);
+    const service = container.get('knowledgeService');
+    return service.incrementUsage(ctx.data.recipeId, 'application');
   });
 
   gateway.register('recipe:list', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.listRecipes(ctx.data.filters, ctx.data.pagination);
+    const service = container.get('knowledgeService');
+    return service.list(ctx.data.filters, ctx.data.pagination);
   });
 
   gateway.register('recipe:search', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.searchRecipes(ctx.data.keyword, ctx.data.pagination);
+    const service = container.get('knowledgeService');
+    return service.search(ctx.data.keyword, ctx.data.pagination);
   });
 
   gateway.register('recipe:get_stats', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.getRecipeStats();
+    const service = container.get('knowledgeService');
+    return service.getStats();
   });
 
   gateway.register('recipe:get', async (ctx) => {
-    const repo = container.get('recipeRepository');
-    return repo.findById(ctx.data.id);
+    const service = container.get('knowledgeService');
+    return service.get(ctx.data.id);
   });
 
   gateway.register('recipe:get_recommendations', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.getRecommendations(ctx.data.limit);
+    const service = container.get('knowledgeService');
+    return service.list({ lifecycle: 'active' }, { page: 1, pageSize: ctx.data.limit || 10 });
   });
 
   gateway.register('recipe:delete', async (ctx) => {
-    const service = container.get('recipeService');
-    return service.deleteRecipe(ctx.data.recipeId, {
+    const service = container.get('knowledgeService');
+    return service.delete(ctx.data.recipeId, {
       userId: ctx.actor,
     });
   });
@@ -200,19 +192,17 @@ export function registerGatewayActions(gateway, container) {
   });
 
   gateway.register('guard_rule:get', async (ctx) => {
-    const repo = container.get('recipeRepository');
+    const repo = container.get('knowledgeRepository');
     return repo.findById(ctx.data.id);
   });
 
   // ========== Search Actions ==========
 
-  // ========== Candidate Update (enrich/refine) ==========
+  // ========== Knowledge Update (enrich/refine) ==========
 
   gateway.register('candidate:update', async (ctx) => {
-    const service = container.get('candidateService');
-    return service.updateCandidate
-      ? service.updateCandidate(ctx.data.id, ctx.data, { userId: ctx.actor })
-      : service.createCandidate(ctx.data, { userId: ctx.actor });
+    const service = container.get('knowledgeService');
+    return service.update(ctx.data.id, ctx.data, { userId: ctx.actor });
   });
 
   // ========== Search ==========

package/lib/domain/index.js

@@ -3,18 +3,23 @@
  * 导出所有实体、值对象和仓储接口
  */
 
-// Candidate 相关
-export { Candidate } from './candidate/Candidate.js';
-export { default as Reasoning } from './candidate/Reasoning.js';
-export { CandidateStatus, isValidCandidateStatus, isValidStateTransition } from './types/CandidateStatus.js';
-export { default as CandidateRepository } from './candidate/CandidateRepository.js';
-
-// Recipe 相关（统一知识实体）
+// Knowledge 统一知识实体 (V3)
 export {
-  Recipe, RecipeStatus, KnowledgeType, Complexity,
-  RelationType, Kind, inferKind,
-} from './recipe/Recipe.js';
-export { default as RecipeRepository } from './recipe/RecipeRepository.js';
+  KnowledgeEntry,
+  Lifecycle,
+  isValidTransition,
+  isValidLifecycle,
+  isCandidate as isLifecycleCandidate,
+  CANDIDATE_STATES,
+  inferKind as inferKindV3,
+} from './knowledge/index.js';
+export { Content } from './knowledge/values/Content.js';
+export { Relations, RELATION_BUCKETS, RELATION_BUCKETS as RelationType } from './knowledge/values/Relations.js';
+export { Constraints } from './knowledge/values/Constraints.js';
+export { Reasoning as ReasoningV3 } from './knowledge/values/Reasoning.js';
+export { Quality } from './knowledge/values/Quality.js';
+export { Stats } from './knowledge/values/Stats.js';
+export { KnowledgeRepository } from './knowledge/KnowledgeRepository.js';
 
 // Snippet 相关
 export { Snippet } from './snippet/Snippet.js';

package/lib/domain/knowledge/KnowledgeEntry.js

@@ -0,0 +1,289 @@
+import { v4 as uuidv4 } from 'uuid';
+import { Lifecycle, isValidTransition, isCandidate as isLifecycleCandidate, inferKind, normalizeLifecycle } from './Lifecycle.js';
+import { Content, Relations, Constraints, Reasoning, Quality, Stats } from './values/index.js';
+
+/* ═══════════════════════════════════════════════════════════
+ * KnowledgeEntry — 统一知识实体
+ *
+ * lifecycle 状态决定其行为（3 状态简化版）：
+ *   pending    → 待审核（新建条目初始状态）
+ *   active     → 已发布（被 Guard/Search/Export 消费）
+ *   deprecated → 已废弃
+ * ═══════════════════════════════════════════════════════════ */
+
+export class KnowledgeEntry {
+  /**
+   * @param {Object} props
+   */
+  constructor(props = {}) {
+    // ── 标识 ──
+    this.id          = props.id          || uuidv4();
+    this.title       = props.title       || '';
+    this.description = props.description || '';
+
+    // ── 生命周期 ──
+    this.lifecycle        = normalizeLifecycle(props.lifecycle || Lifecycle.PENDING);
+    this.lifecycleHistory = props.lifecycleHistory  || [];
+    this.autoApprovable   = props.autoApprovable    ?? false;
+
+    // ── 语言与分类 ──
+    this.language      = props.language      || '';
+    this.category      = props.category      || '';
+    this.knowledgeType = props.knowledgeType  || 'code-pattern';
+    this.kind          = props.kind          || inferKind(this.knowledgeType);
+    this.complexity    = props.complexity    || 'intermediate';
+    this.scope         = props.scope         || 'universal';
+    this.difficulty    = props.difficulty    || null;
+    this.tags          = props.tags          || [];
+
+    // ── Cursor 交付字段（AI 直接产出）──
+    this.trigger     = props.trigger     || '';
+    this.topicHint   = props.topicHint   || '';
+    this.whenClause  = props.whenClause  || '';
+    this.doClause    = props.doClause    || '';
+    this.dontClause  = props.dontClause  || '';
+    this.coreCode    = props.coreCode    || '';
+
+    // ── 值对象 ──
+    this.content     = Content.from(props.content);
+    this.relations   = Relations.from(props.relations);
+    this.constraints = Constraints.from(props.constraints);
+    this.reasoning   = Reasoning.from(props.reasoning);
+    this.quality     = Quality.from(props.quality);
+    this.stats       = Stats.from(props.stats);
+
+    // ── 代码头文件 (ObjC/Swift) ──
+    this.headers        = props.headers        || [];
+    this.headerPaths    = props.headerPaths    || [];
+    this.moduleName     = props.moduleName     || '';
+    this.includeHeaders = props.includeHeaders ?? false;
+
+    // ── AI 润色 ──
+    this.agentNotes = props.agentNotes || null;
+    this.aiInsight  = props.aiInsight  || null;
+
+    // ── 审核 ──
+    this.reviewedBy      = props.reviewedBy      || null;
+    this.reviewedAt      = props.reviewedAt      || null;
+    this.rejectionReason = props.rejectionReason  || null;
+
+    // ── 来源 ──
+    this.source            = props.source            || 'manual';
+    this.sourceFile        = props.sourceFile        || null;
+    this.sourceCandidateId = props.sourceCandidateId || null;
+
+    // ── 时间 ──
+    this.createdBy   = props.createdBy   || 'system';
+    this.createdAt   = props.createdAt   || Math.floor(Date.now() / 1000);
+    this.updatedAt   = props.updatedAt   || Math.floor(Date.now() / 1000);
+    this.publishedAt = props.publishedAt || null;
+    this.publishedBy = props.publishedBy || null;
+  }
+
+  /* ═══ 生命周期操作 ═══════════════════════════════════ */
+
+  /**
+   * 发布 (pending → active)
+   * @param {string} publisher
+   * @returns {{ success: boolean, error?: string }}
+   */
+  publish(publisher) {
+    if (!this.isValid()) {
+      return { success: false, error: '内容不完整，无法发布' };
+    }
+    const result = this._transition(Lifecycle.ACTIVE);
+    if (result.success) {
+      this.publishedAt = this._now();
+      this.publishedBy = publisher;
+    }
+    return result;
+  }
+
+  /**
+   * 弃用 (pending|active → deprecated)
+   * @param {string} reason
+   * @returns {{ success: boolean, error?: string }}
+   */
+  deprecate(reason) {
+    const result = this._transition(Lifecycle.DEPRECATED);
+    if (result.success) {
+      this.rejectionReason = reason;
+    }
+    return result;
+  }
+
+  /**
+   * 重新激活 (deprecated → pending)
+   * @returns {{ success: boolean, error?: string }}
+   */
+  reactivate() {
+    const result = this._transition(Lifecycle.PENDING);
+    if (result.success) {
+      this.rejectionReason = null;
+    }
+    return result;
+  }
+
+  /* ═══ 谓词 ═══════════════════════════════════════════ */
+
+  /**
+   * 是否处于候选阶段
+   * @returns {boolean}
+   */
+  isCandidate() {
+    return isLifecycleCandidate(this.lifecycle);
+  }
+
+  /**
+   * 是否可被 Guard/Search/Export 消费
+   * @returns {boolean}
+   */
+  isActive() {
+    return this.lifecycle === Lifecycle.ACTIVE;
+  }
+
+  /**
+   * 是否为 Guard 规则类型
+   * @returns {boolean}
+   */
+  isRule() {
+    return this.kind === 'rule';
+  }
+
+  /**
+   * 内容是否有效
+   * @returns {boolean}
+   */
+  isValid() {
+    return !!(this.title?.trim() && this.content.hasContent());
+  }
+
+  /* ═══ Guard 消费 ═══════════════════════════════════ */
+
+  /**
+   * 返回此 Entry 中可被 GuardCheckEngine 消费的规则列表
+   * @returns {Array<Object>}
+   */
+  getGuardRules() {
+    if (!this.isActive() || !this.isRule()) return [];
+
+    const regexRules = this.constraints.getRegexGuards().map(g => ({
+      id:            g.id || this.id,
+      type:          'regex',
+      name:          g.message || this.title,
+      message:       g.message || this.description || this.title,
+      pattern:       g.pattern,
+      languages:     this.language ? [this.language] : [],
+      severity:      g.severity || 'warning',
+      source:        'knowledge_entry',
+      fixSuggestion: g.fix_suggestion || null,
+    }));
+
+    const astRules = this.constraints.getAstGuards().map(g => ({
+      id:            g.id || `${this.id}:ast`,
+      type:          'ast',
+      name:          g.message || this.title,
+      message:       g.message,
+      astQuery:      g.ast_query,
+      languages:     g.ast_query?.language ? [g.ast_query.language] : [],
+      severity:      g.severity || 'warning',
+      source:        'knowledge_entry',
+      fixSuggestion: g.fix_suggestion || null,
+    }));
+
+    return [...regexRules, ...astRules];
+  }
+
+  /* ═══ 序列化 ═══════════════════════════════════════ */
+
+  /**
+   * Domain → JSON (camelCase 直出，全链路统一)
+   */
+  toJSON() {
+    return {
+      id:                this.id,
+      title:             this.title,
+      description:       this.description,
+      lifecycle:         this.lifecycle,
+      lifecycleHistory:  this.lifecycleHistory,
+      autoApprovable:    this.autoApprovable,
+      language:          this.language,
+      category:          this.category,
+      kind:              this.kind,
+      knowledgeType:     this.knowledgeType,
+      complexity:        this.complexity,
+      scope:             this.scope,
+      difficulty:        this.difficulty,
+      tags:              this.tags,
+      trigger:           this.trigger,
+      topicHint:         this.topicHint,
+      whenClause:        this.whenClause,
+      doClause:          this.doClause,
+      dontClause:        this.dontClause,
+      coreCode:          this.coreCode,
+      content:           this.content.toJSON(),
+      relations:         this.relations.toJSON(),
+      constraints:       this.constraints.toJSON(),
+      reasoning:         this.reasoning.toJSON(),
+      quality:           this.quality.toJSON(),
+      stats:             this.stats.toJSON(),
+      headers:           this.headers,
+      headerPaths:       this.headerPaths,
+      moduleName:        this.moduleName,
+      includeHeaders:    this.includeHeaders,
+      agentNotes:        this.agentNotes,
+      aiInsight:         this.aiInsight,
+      reviewedBy:        this.reviewedBy,
+      reviewedAt:        this.reviewedAt,
+      rejectionReason:   this.rejectionReason,
+      source:            this.source,
+      sourceFile:        this.sourceFile,
+      sourceCandidateId: this.sourceCandidateId,
+      createdBy:         this.createdBy,
+      createdAt:         this.createdAt,
+      updatedAt:         this.updatedAt,
+      publishedAt:       this.publishedAt,
+      publishedBy:       this.publishedBy,
+    };
+  }
+
+  /**
+   * JSON → Domain (camelCase 直入)
+   * @param {Object} data
+   * @returns {KnowledgeEntry}
+   */
+  static fromJSON(data) {
+    if (!data) return new KnowledgeEntry();
+    return new KnowledgeEntry(data);
+  }
+
+  /* ═══ 私有 ═══════════════════════════════════════════ */
+
+  /**
+   * @param {string} to
+   * @returns {{ success: boolean, error?: string }}
+   */
+  _transition(to) {
+    if (!isValidTransition(this.lifecycle, to)) {
+      return {
+        success: false,
+        error: `Invalid lifecycle transition: ${this.lifecycle} → ${to}`,
+      };
+    }
+    this.lifecycleHistory.push({
+      from: this.lifecycle,
+      to,
+      at: this._now(),
+    });
+    this.lifecycle = to;
+    this.updatedAt = this._now();
+    return { success: true };
+  }
+
+  /** @returns {number} */
+  _now() {
+    return Math.floor(Date.now() / 1000);
+  }
+}
+
+export default KnowledgeEntry;

package/lib/domain/knowledge/KnowledgeRepository.js

@@ -0,0 +1,123 @@
+/**
+ * KnowledgeRepository — 统一知识实体仓储接口
+ *
+ * 替代 CandidateRepository + RecipeRepository。
+ * 实现类见 lib/repository/knowledge/KnowledgeRepository.impl.js
+ */
+export class KnowledgeRepository {
+
+  /**
+   * 创建 KnowledgeEntry
+   * @param {import('./KnowledgeEntry.js').KnowledgeEntry} entry
+   * @returns {Promise<import('./KnowledgeEntry.js').KnowledgeEntry>}
+   */
+  async create(entry) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 根据 ID 获取
+   * @param {string} id
+   * @returns {Promise<import('./KnowledgeEntry.js').KnowledgeEntry|null>}
+   */
+  async findById(id) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 分页查询
+   * @param {Object} filters - { lifecycle, kind, language, category, knowledgeType, source }
+   * @param {Object} options - { page, pageSize, orderBy, order }
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async findWithPagination(filters = {}, options = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 根据生命周期状态查询
+   * @param {string} lifecycle
+   * @param {Object} pagination
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async findByLifecycle(lifecycle, pagination = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 根据 kind 查询
+   * @param {string} kind - 'rule' | 'pattern' | 'fact'
+   * @param {Object} options - { page, pageSize, lifecycle }
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async findByKind(kind, options = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 查询所有 active 的 rule 类型（Guard 消费热路径）
+   * @returns {Promise<KnowledgeEntry[]>}
+   */
+  async findActiveRules() {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 根据语言查询
+   * @param {string} language
+   * @param {Object} pagination
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async findByLanguage(language, pagination = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 根据分类查询
+   * @param {string} category
+   * @param {Object} pagination
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async findByCategory(category, pagination = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 搜索 (标题/内容/触发词/标签)
+   * @param {string} keyword
+   * @param {Object} pagination
+   * @returns {Promise<{ data: KnowledgeEntry[], pagination: Object }>}
+   */
+  async search(keyword, pagination = {}) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 更新
+   * @param {string} id
+   * @param {Object} updates - wire format 的部分字段
+   * @returns {Promise<import('./KnowledgeEntry.js').KnowledgeEntry>}
+   */
+  async update(id, updates) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 删除
+   * @param {string} id
+   * @returns {Promise<boolean>}
+   */
+  async delete(id) {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * 获取统计信息
+   * @returns {Promise<Object>}
+   */
+  async getStats() {
+    throw new Error('Not implemented');
+  }
+}
+
+export default KnowledgeRepository;