autosnippet 2.8.3 → 2.10.0

package/lib/external/mcp/handlers/knowledge.js

@@ -0,0 +1,205 @@
+/**
+ * MCP Handlers — V3 知识条目提交 & 生命周期
+ * submitKnowledge, submitKnowledgeBatch, knowledgeLifecycle
+ */
+
+import { envelope } from '../envelope.js';
+import { checkRecipeReadiness } from '../../../shared/RecipeReadinessChecker.js';
+
+// ─── 限流 ──────────────────────────────────────────────────
+
+async function _checkRateLimit(toolName, clientId) {
+  const { checkRecipeSave } = await import('../../../http/middleware/RateLimiter.js');
+  const projectRoot = process.cwd();
+  const limitCheck = checkRecipeSave(projectRoot, clientId || process.env.USER || 'mcp-client');
+  if (!limitCheck.allowed) {
+    return envelope({
+      success: false,
+      message: `提交过于频繁，请 ${limitCheck.retryAfter}s 后再试。`,
+      errorCode: 'RATE_LIMIT',
+      meta: { tool: toolName },
+    });
+  }
+  return null;
+}
+
+// ─── V3 wire format → KnowledgeService.create() 直通 ────────
+
+/**
+ * 单条知识提交 (autosnippet_submit_knowledge)
+ *
+ * args 就是 wire format — 直接交给 knowledgeService.create()。
+ * 无需字段映射，fromJSON() 处理一切。
+ */
+export async function submitKnowledge(ctx, args) {
+  // 限流
+  const blocked = await _checkRateLimit('autosnippet_submit_knowledge', args.client_id);
+  if (blocked) return blocked;
+
+  const service = ctx.container.get('knowledgeService');
+
+  // MCP 参数直接是 wire format
+  const entry = await service.create(args, { userId: 'mcp' });
+
+  // Recipe-Ready 诊断（兼容旧格式）
+  const readinessInput = _toReadinessInput(args);
+  const readiness = checkRecipeReadiness(readinessInput);
+
+  const data = {
+    id: entry.id,
+    lifecycle: entry.lifecycle,
+    title: entry.title,
+    kind: entry.kind,
+  };
+
+  if (!readiness.ready) {
+    data.recipeReadyHints = {
+      ready: false,
+      missingFields: readiness.missing,
+      suggestions: readiness.suggestions,
+      hint: '请补全以上字段后重新提交，或调用 autosnippet_enrich_candidates 进行完整性诊断',
+    };
+  }
+
+  return envelope({
+    success: true,
+    data,
+    meta: { tool: 'autosnippet_submit_knowledge' },
+  });
+}
+
+/**
+ * 批量知识提交 (autosnippet_submit_knowledge_batch)
+ */
+export async function submitKnowledgeBatch(ctx, args) {
+  if (!args.target_name || !Array.isArray(args.items) || args.items.length === 0) {
+    throw new Error('需要 target_name 与 items（非空数组）');
+  }
+
+  // 限流
+  const blocked = await _checkRateLimit('autosnippet_submit_knowledge_batch', args.client_id);
+  if (blocked) return blocked;
+
+  // 去重（可选）
+  let items = args.items;
+  if (args.deduplicate !== false) {
+    try {
+      const { aggregateCandidates } = await import('../../../service/candidate/CandidateAggregator.js');
+      // 对 title 字段做去重
+      const readinessItems = items.map(it => ({
+        ...it,
+        code: it.content?.pattern || it.code || '',
+      }));
+      const result = aggregateCandidates(readinessItems);
+      // 保留原始 items 顺序中去重后的
+      if (result.items && result.items.length < items.length) {
+        const titles = new Set(result.items.map(it => it.title));
+        items = items.filter(it => titles.has(it.title));
+      }
+    } catch {
+      // CandidateAggregator 加载失败时降级：不去重
+    }
+  }
+
+  const service = ctx.container.get('knowledgeService');
+  const source = args.source || 'cursor-scan';
+  let count = 0;
+  const itemErrors = [];
+
+  for (let i = 0; i < items.length; i++) {
+    try {
+      const itemData = { ...items[i], source };
+      await service.create(itemData, { userId: 'mcp' });
+      count++;
+    } catch (err) {
+      itemErrors.push({ index: i, title: items[i].title || '(untitled)', error: err.message });
+    }
+  }
+
+  const data = { count, total: items.length, targetName: args.target_name };
+  if (itemErrors.length > 0) data.errors = itemErrors;
+
+  // Recipe-Ready 统计
+  const notReady = items.filter(it => !checkRecipeReadiness(_toReadinessInput(it)).ready);
+  if (notReady.length > 0) {
+    const allMissing = [...new Set(notReady.flatMap(it => checkRecipeReadiness(_toReadinessInput(it)).missing))];
+    data.recipeReadyHints = {
+      notReadyCount: notReady.length,
+      totalCount: items.length,
+      commonMissingFields: allMissing,
+      hint: `${notReady.length}/${items.length} 条知识条目缺少必要字段（${allMissing.join(', ')}），请补全后重新提交`,
+    };
+  }
+
+  return envelope({
+    success: true,
+    data,
+    message: `已提交 ${count}/${items.length} 条知识条目。`,
+    meta: { tool: 'autosnippet_submit_knowledge_batch' },
+  });
+}
+
+/**
+ * 知识条目生命周期操作 (autosnippet_knowledge_lifecycle)
+ *
+ * 简化为 3 状态: pending / active / deprecated
+ * 外部 Agent 允许 reactivate（废弃 → 待审核）；发布/废弃由开发者在 Dashboard 操作
+ * 外部 Agent 也可以通过 submitKnowledge / submitKnowledgeBatch 提交新条目（→ pending）
+ */
+const MCP_ALLOWED_LIFECYCLE_ACTIONS = new Set(['reactivate']);
+
+export async function knowledgeLifecycle(ctx, args) {
+  const { id, action } = args;
+  if (!id || !action) {
+    throw new Error('需要 id 和 action');
+  }
+
+  if (!MCP_ALLOWED_LIFECYCLE_ACTIONS.has(action)) {
+    throw new Error(
+      `[PERMISSION_DENIED] 外部 Agent 不允许执行 "${action}" 操作，仅支持: reactivate。发布、废弃等操作请在 Dashboard 中完成。提交新知识请使用 autosnippet_submit_knowledge 工具。`
+    );
+  }
+
+  const service = ctx.container.get('knowledgeService');
+  const context = { userId: 'mcp' };
+
+  const entry = await service.reactivate(id, context);
+
+  return envelope({
+    success: true,
+    data: {
+      id: entry.id,
+      lifecycle: entry.lifecycle,
+      title: entry.title,
+      action,
+    },
+    meta: { tool: 'autosnippet_knowledge_lifecycle' },
+  });
+}
+
+// ─── 内部辅助 ──────────────────────────────────────────────
+
+/**
+ * V3 wire format → RecipeReadinessChecker 兼容格式
+ * RecipeReadinessChecker 期望旧字段名 (code, summary_cn, ...)
+ */
+function _toReadinessInput(args) {
+  return {
+    title: args.title,
+    code: args.content?.pattern || args.code || '',
+    language: args.language,
+    category: args.category,
+    trigger: args.trigger,
+    summary_cn: args.summary_cn,
+    summary_en: args.summary_en,
+    headers: args.headers,
+    reasoning: args.reasoning ? {
+      whyStandard: args.reasoning.why_standard || args.reasoning.whyStandard,
+      sources: args.reasoning.sources,
+      confidence: args.reasoning.confidence,
+    } : undefined,
+    knowledgeType: args.knowledge_type || args.knowledgeType,
+    complexity: args.complexity,
+    usageGuide: args.usage_guide_cn || args.usageGuide,
+  };
+}

package/lib/external/mcp/handlers/skill.js

@@ -613,8 +613,10 @@ export function updateSkill(_ctx, args) {
 export async function suggestSkills(ctx) {
   try {
     const { SkillAdvisor } = await import('../../../service/skills/SkillAdvisor.js');
-    const database = ctx?.container?.get?.('database') || null;
-    const advisor = new SkillAdvisor(PROJECT_ROOT, { database });
+    const dbConn = ctx?.container?.get?.('database') || null;
+    const database = dbConn?.getDb?.() || dbConn || null;
+    const projectRoot = process.env.ASD_PROJECT_DIR || process.cwd();
+    const advisor = new SkillAdvisor(projectRoot, { database });
     const result = advisor.suggest();
 
     return JSON.stringify({

package/lib/external/mcp/handlers/structure.js

@@ -262,40 +262,41 @@ export async function graphImpact(ctx, args) {
 }
 
 /**
- * 降级：从 Recipe.relations_json 提取关系（不依赖 knowledge_edges 表）
+ * 降级：从 knowledge_entries.relations 提取关系（不依赖 knowledge_edges 表）
  */
 async function _fallbackRelationsFromRecipe(ctx, nodeId, relation, direction) {
-  const recipeService = ctx.container.get('recipeService');
   try {
-    const recipe = await recipeService.getRecipe(nodeId);
-    if (!recipe) return { outgoing: [], incoming: [] };
+    const knowledgeService = ctx.container.get('knowledgeService');
+    const entry = await knowledgeService.get(nodeId);
+    if (!entry) return { outgoing: [], incoming: [] };
 
+    const relJson = typeof entry.relations?.toJSON === 'function' ? entry.relations.toJSON() : (entry.relations || {});
     const outgoing = [];
     if (direction === 'both' || direction === 'out') {
-      for (const [relType, targets] of Object.entries(recipe.relations || {})) {
+      for (const [relType, targets] of Object.entries(relJson)) {
         if (relation && relType !== relation) continue;
         for (const t of (Array.isArray(targets) ? targets : [])) {
-          outgoing.push({ fromId: nodeId, fromType: 'recipe', toId: t.target || t.id || t, toType: 'recipe', relation: relType });
+          outgoing.push({ fromId: nodeId, fromType: 'knowledge', toId: t.target || t.id || t, toType: 'knowledge', relation: relType });
         }
       }
     }
 
-    // 反向查找：其他 Recipe 中 relations_json 包含当前 nodeId
+    // 反向查找：其他条目中 relations 包含当前 nodeId
     const incoming = [];
     if (direction === 'both' || direction === 'in') {
-      const recipeRepo = ctx.container.get('recipeRepository');
-      const reverseRows = recipeRepo.db.prepare(
-        `SELECT id, relations_json FROM recipes WHERE relations_json LIKE ? AND id != ?`
+      const knowledgeRepo = ctx.container.get('knowledgeRepository');
+      const reverseRows = knowledgeRepo.db.prepare(
+        `SELECT id, relations FROM knowledge_entries WHERE relations LIKE ? AND id != ?`
       ).all(`%${nodeId}%`, nodeId);
       for (const row of reverseRows) {
         try {
-          const rels = JSON.parse(row.relations_json || '{}');
+          const rels = JSON.parse(row.relations || '{}');
           for (const [relType, targets] of Object.entries(rels)) {
             if (relation && relType !== relation) continue;
             for (const t of (Array.isArray(targets) ? targets : [])) {
               const targetId = t.target || t.id || t;
               if (targetId === nodeId) {
-                incoming.push({ fromId: row.id, fromType: 'recipe', toId: nodeId, toType: 'recipe', relation: relType });
+                incoming.push({ fromId: row.id, fromType: 'knowledge', toId: nodeId, toType: 'knowledge', relation: relType });
               }
             }
           }
@@ -308,23 +309,23 @@ async function _fallbackRelationsFromRecipe(ctx, nodeId, relation, direction) {
 }
 
 /**
- * 降级：从 relations_json 反查受影响的 Recipe
+ * 降级：从 knowledge_entries.relations 反查受影响的条目
  */
 async function _fallbackImpactFromRecipe(ctx, nodeId) {
   try {
-    const recipeRepo = ctx.container.get('recipeRepository');
-    const rows = recipeRepo.db.prepare(
-      `SELECT id, title, relations_json FROM recipes WHERE relations_json LIKE ? AND id != ?`
+    const knowledgeRepo = ctx.container.get('knowledgeRepository');
+    const rows = knowledgeRepo.db.prepare(
+      `SELECT id, title, relations FROM knowledge_entries WHERE relations LIKE ? AND id != ?`
     ).all(`%${nodeId}%`, nodeId);
 
     const impacted = [];
     for (const row of rows) {
       try {
-        const rels = JSON.parse(row.relations_json || '{}');
+        const rels = JSON.parse(row.relations || '{}');
         for (const [relType, targets] of Object.entries(rels)) {
           for (const t of (Array.isArray(targets) ? targets : [])) {
             if ((t.target || t.id || t) === nodeId) {
-              impacted.push({ id: row.id, title: row.title, type: 'recipe', relation: relType, depth: 1 });
+              impacted.push({ id: row.id, title: row.title, type: 'knowledge', relation: relType, depth: 1 });
             }
           }
         }
@@ -364,17 +365,18 @@ export async function graphPath(ctx, args) {
  */
 async function _fallbackPathFromRecipe(ctx, fromId, toId) {
   try {
-    const recipeService = ctx.container.get('recipeService');
-    const recipe = await recipeService.getRecipe(fromId);
-    if (!recipe) return { found: false, path: [], depth: -1 };
+    const knowledgeService = ctx.container.get('knowledgeService');
+    const entry = await knowledgeService.get(fromId);
+    if (!entry) return { found: false, path: [], depth: -1 };
 
-    for (const [relType, targets] of Object.entries(recipe.relations || {})) {
+    const relJson = typeof entry.relations?.toJSON === 'function' ? entry.relations.toJSON() : (entry.relations || {});
+    for (const [relType, targets] of Object.entries(relJson)) {
       for (const t of (Array.isArray(targets) ? targets : [])) {
         const targetId = t.target || t.id || t;
         if (targetId === toId) {
           return {
             found: true,
-            path: [{ from: { id: fromId, type: 'recipe' }, to: { id: toId, type: 'recipe' }, relation: relType }],
+            path: [{ from: { id: fromId, type: 'knowledge' }, to: { id: toId, type: 'knowledge' }, relation: relType }],
             depth: 1,
           };
         }

package/lib/external/mcp/handlers/system.js

@@ -30,22 +30,23 @@ export async function health(ctx) {
       checks.database = true;
       // 知识库统计（轻量聚合查询）
       try {
+        // V3: knowledge_entries 统一表（lifecycle 替代 status）
         const rStats = db.prepare(`
           SELECT COUNT(*) as total,
-            SUM(CASE WHEN status='active' THEN 1 ELSE 0 END) as active,
+            SUM(CASE WHEN lifecycle='active' THEN 1 ELSE 0 END) as active,
             SUM(CASE WHEN kind='rule' THEN 1 ELSE 0 END) as rules,
             SUM(CASE WHEN kind='pattern' THEN 1 ELSE 0 END) as patterns,
             SUM(CASE WHEN kind='fact' THEN 1 ELSE 0 END) as facts
-          FROM recipes
+          FROM knowledge_entries
         `).get();
-        const cStats = db.prepare(`
+        const cPending = db.prepare(`
           SELECT COUNT(*) as total,
-            SUM(CASE WHEN status='pending' THEN 1 ELSE 0 END) as pending
-          FROM candidates
+            SUM(CASE WHEN lifecycle='pending' THEN 1 ELSE 0 END) as pending
+          FROM knowledge_entries
         `).get();
         knowledgeBase = {
           recipes: { total: rStats.total, active: rStats.active, rules: rStats.rules, patterns: rStats.patterns, facts: rStats.facts },
-          candidates: { total: cStats.total, pending: cStats.pending },
+          candidates: { total: cPending.total, pending: cPending.pending },
         };
       } catch { /* 统计查询失败不影响 health */ }
     }
@@ -132,9 +133,6 @@ export function capabilities() {
     autosnippet_get_target_metadata: 'structure',
     autosnippet_validate_candidate: 'validate',
     autosnippet_check_duplicate: 'validate',
-    autosnippet_submit_candidate: 'submit',
-    autosnippet_submit_candidates: 'submit',
-    autosnippet_submit_draft_recipes: 'submit',
     autosnippet_guard_check: 'guard',
     autosnippet_guard_audit_files: 'guard',
     autosnippet_scan_project: 'scan',
@@ -191,9 +189,9 @@ export function capabilities() {
       tools,
       workflows: [
         { name: '知识查询', steps: ['search（推荐首选，auto mode 融合）', 'get_recipe', 'confirm_usage'], tips: '精确匹配用 keyword_search，需意图+会话上下文用 context_search' },
-        { name: '单文件候选提交', steps: ['check_duplicate', 'validate_candidate', 'submit_candidate'] },
-        { name: '批量 Target 扫描', steps: ['get_targets', 'get_target_files', '(Agent 分析)', 'submit_candidates'] },
-        { name: '全项目深度扫描', steps: ['scan_project', '(Agent 语义分析)', 'submit_candidates', 'enrich_candidates'] },
+        { name: '单条知识提交', steps: ['check_duplicate', 'validate_candidate', 'submit_knowledge'] },
+        { name: '批量 Target 扫描', steps: ['get_targets', 'get_target_files', '(Agent 分析)', 'submit_knowledge_batch'] },
+        { name: '全项目深度扫描', steps: ['scan_project', '(Agent 语义分析)', 'submit_knowledge_batch', 'enrich_candidates'] },
         { name: '候选就绪检查', steps: ['enrich_candidates', 'validate_candidate', 'check_duplicate'] },
       ],
     },