autosnippet 3.3.4 → 3.3.6

package/dist/lib/external/mcp/handlers/evolve-external.js

@@ -0,0 +1,226 @@
+/**
+ * MCP Handler — autosnippet_evolve (批量 Recipe 进化决策)
+ *
+ * 双入口工具：
+ *   - Rescan 模式: 每个维度内先 evolve 再 gap-fill，与内部 Agent Pipeline 一致
+ *   - 独立模式: 用户通过提示词触发，验证已有 Recipe 的有效性
+ *
+ * 三种决策委托给 evolution-tools.ts 中已有的 handler 实现：
+ *   - propose_evolution → ProposalRepository.create (观察窗口)
+ *   - confirm_deprecation → RecipeLifecycleSupervisor.transition → deprecated (优先) / KnowledgeService.deprecate (回退)
+ *   - skip → 不变更状态，skip(still_valid) 刷新 stats.lastVerifiedAt
+ *
+ * @module handlers/evolve-external
+ */
+import { envelope } from '../envelope.js';
+// ── 主入口 ─────────────────────────────────────────────────
+export async function evolveExternal(ctx, args) {
+    const t0 = Date.now();
+    const { decisions } = args;
+    if (!decisions || decisions.length === 0) {
+        return envelope({
+            success: true,
+            data: {
+                processed: 0,
+                proposed: 0,
+                deprecated: 0,
+                skipped: 0,
+                refreshed: 0,
+                quotaChange: { freed: 0, occupied: 0 },
+                errors: [],
+            },
+            message: '⚠️ 没有提交任何 evolve 决策',
+            meta: { tool: 'autosnippet_evolve', responseTimeMs: Date.now() - t0 },
+        });
+    }
+    const result = {
+        processed: 0,
+        proposed: 0,
+        deprecated: 0,
+        skipped: 0,
+        refreshed: 0,
+        quotaChange: { freed: 0, occupied: 0 },
+        errors: [],
+    };
+    const proposalRepo = ctx.container.get('proposalRepository');
+    const knowledgeService = ctx.container.get('knowledgeService');
+    const supervisor = ctx.container.get('lifecycleSupervisor');
+    const dbConn = ctx.container.get('database');
+    const rawDb = dbConn?.db ?? null;
+    for (const decision of decisions) {
+        try {
+            // O4: Recipe 存在性前置检查
+            if (rawDb) {
+                const exists = rawDb
+                    .prepare('SELECT 1 FROM knowledge_entries WHERE id = ?')
+                    .get(decision.recipeId);
+                if (!exists) {
+                    result.errors.push({ recipeId: decision.recipeId, error: 'Recipe not found' });
+                    result.processed++;
+                    continue;
+                }
+            }
+            switch (decision.action) {
+                case 'propose_evolution': {
+                    if (!proposalRepo) {
+                        result.errors.push({
+                            recipeId: decision.recipeId,
+                            error: 'ProposalRepository not available',
+                        });
+                        break;
+                    }
+                    if (!decision.evidence) {
+                        result.errors.push({
+                            recipeId: decision.recipeId,
+                            error: 'evidence is required for propose_evolution',
+                        });
+                        break;
+                    }
+                    const proposal = proposalRepo.create({
+                        type: decision.evidence.type,
+                        targetRecipeId: decision.recipeId,
+                        relatedRecipeIds: [],
+                        confidence: 0.8,
+                        source: 'ide-agent',
+                        description: decision.evidence.suggestedChanges,
+                        evidence: [
+                            {
+                                sourceStatus: 'modified',
+                                currentCode: decision.evidence.codeSnippet,
+                                filePath: decision.evidence.filePath,
+                                suggestedChanges: decision.evidence.suggestedChanges,
+                                verifiedBy: 'ide-agent',
+                                verifiedAt: Date.now(),
+                            },
+                        ],
+                    });
+                    if (proposal) {
+                        result.proposed++;
+                        ctx.logger.info(`[Evolve] propose_evolution: ${decision.recipeId} → proposal ${proposal.id}`);
+                    }
+                    else {
+                        result.errors.push({
+                            recipeId: decision.recipeId,
+                            error: 'Failed to create proposal (target recipe may not exist or duplicate proposal)',
+                        });
+                    }
+                    break;
+                }
+                case 'confirm_deprecation': {
+                    // O1: 优先通过 RecipeLifecycleSupervisor 执行，回退到 KnowledgeService
+                    const reason = decision.reason || 'IDE Agent confirmed deprecation';
+                    if (supervisor) {
+                        const transResult = supervisor.transition({
+                            recipeId: decision.recipeId,
+                            targetState: 'deprecated',
+                            trigger: 'manual-deprecation',
+                            evidence: { reason },
+                            operatorId: 'ide-agent',
+                        });
+                        if (!transResult.success) {
+                            // Supervisor 拒绝（可能状态不允许直接转 deprecated），回退到 KnowledgeService
+                            if (knowledgeService) {
+                                await knowledgeService.deprecate(decision.recipeId, reason, {
+                                    userId: 'ide-agent',
+                                });
+                            }
+                            else {
+                                result.errors.push({
+                                    recipeId: decision.recipeId,
+                                    error: `Supervisor rejected: ${transResult.error}`,
+                                });
+                                break;
+                            }
+                        }
+                    }
+                    else if (knowledgeService) {
+                        // P3: 添加 await
+                        await knowledgeService.deprecate(decision.recipeId, reason, { userId: 'ide-agent' });
+                    }
+                    else {
+                        result.errors.push({
+                            recipeId: decision.recipeId,
+                            error: 'Neither Supervisor nor KnowledgeService available',
+                        });
+                        break;
+                    }
+                    // 解决关联的 deprecate proposal
+                    if (proposalRepo) {
+                        try {
+                            const existing = proposalRepo.findByTarget(decision.recipeId);
+                            for (const p of existing) {
+                                if (p.type === 'deprecate') {
+                                    proposalRepo.markExecuted(p.id, `IDE Agent confirmed deprecation: ${reason}`, 'ide-agent');
+                                }
+                            }
+                        }
+                        catch {
+                            // ProposalRepository 操作失败时静默
+                        }
+                    }
+                    result.deprecated++;
+                    result.quotaChange.freed++;
+                    ctx.logger.info(`[Evolve] confirm_deprecation: ${decision.recipeId}`);
+                    break;
+                }
+                case 'skip': {
+                    if (decision.skipReason === 'still_valid' && rawDb) {
+                        // P4: 更新 stats.lastVerifiedAt 而非 updated_at
+                        try {
+                            const row = rawDb
+                                .prepare('SELECT stats FROM knowledge_entries WHERE id = ?')
+                                .get(decision.recipeId);
+                            const stats = JSON.parse(row?.stats || '{}');
+                            stats.lastVerifiedAt = Date.now();
+                            rawDb
+                                .prepare('UPDATE knowledge_entries SET stats = ? WHERE id = ?')
+                                .run(JSON.stringify(stats), decision.recipeId);
+                            result.refreshed++;
+                        }
+                        catch {
+                            // DB 更新失败时静默
+                        }
+                    }
+                    result.skipped++;
+                    ctx.logger.info(`[Evolve] skip: ${decision.recipeId} (${decision.skipReason || 'no reason'})`);
+                    break;
+                }
+                default: {
+                    result.errors.push({
+                        recipeId: decision.recipeId,
+                        error: `Unknown action: ${decision.action}`,
+                    });
+                }
+            }
+            result.processed++;
+        }
+        catch (err) {
+            result.errors.push({
+                recipeId: decision.recipeId,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            result.processed++;
+        }
+    }
+    const parts = [];
+    if (result.proposed > 0) {
+        parts.push(`${result.proposed} 个进化提案`);
+    }
+    if (result.deprecated > 0) {
+        parts.push(`${result.deprecated} 个废弃`);
+    }
+    if (result.refreshed > 0) {
+        parts.push(`${result.refreshed} 个仍然有效`);
+    }
+    if (result.skipped - result.refreshed > 0) {
+        parts.push(`${result.skipped - result.refreshed} 个跳过`);
+    }
+    const summary = parts.length > 0 ? parts.join(', ') : '无变更';
+    return envelope({
+        success: true,
+        data: result,
+        message: `✅ 处理了 ${result.processed} 个 Recipe: ${summary}` +
+            (result.errors.length > 0 ? ` (${result.errors.length} 个错误)` : ''),
+        meta: { tool: 'autosnippet_evolve', responseTimeMs: Date.now() - t0 },
+    });
+}

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

@@ -70,6 +70,13 @@ export async function submitKnowledge(ctx, args) {
     // V3 字段增强
     const enrichedData = _enrichToV3(args, ctx.container);
     const entry = await service.create(enrichedData, { userId: 'mcp' });
+    // ── QualityScorer 自动评分（R9: create 后置执行）──
+    try {
+        await service.updateQuality(entry.id, { userId: 'mcp' });
+    }
+    catch {
+        /* best effort — 不阻塞创建流程 */
+    }
     const data = {
         id: entry.id,
         lifecycle: entry.lifecycle,
@@ -134,8 +141,6 @@ export async function submitKnowledgeBatch(ctx, args) {
     const itemErrors = [];
     const rejectedItems = [];
     const successIds = []; // 成功入库的 recipe ID 列表，供 dimension_complete 使用
-    // UnifiedValidator — 统一前置校验
-    const validator = new UnifiedValidator();
     let session = null;
     let currentDimId = null;
     try {
@@ -151,6 +156,18 @@ export async function submitKnowledgeBatch(ctx, args) {
     catch {
         /* best effort */
     }
+    // UnifiedValidator — 统一前置校验
+    // v3: 注入前序维度已提交的标题，实现跨维度硬去重
+    let existingTitles;
+    try {
+        if (session?.submissionTracker?.getAllSubmittedTitles) {
+            existingTitles = session.submissionTracker.getAllSubmittedTitles();
+        }
+    }
+    catch {
+        /* best effort */
+    }
+    const validator = new UnifiedValidator(existingTitles ? { existingTitles } : {});
     for (let i = 0; i < items.length; i++) {
         // ── 严格前置校验：缺少必要字段的条目直接拒绝，不入库 ──
         const validation = validator.validate(items[i], { skipUniqueness: false });
@@ -177,6 +194,13 @@ export async function submitKnowledgeBatch(ctx, args) {
         try {
             const itemData = _enrichToV3({ ...items[i], source }, ctx.container);
             const entry = await service.create(itemData, { userId: 'mcp' });
+            // ── QualityScorer 自动评分（R9: create 后置执行）──
+            try {
+                await service.updateQuality(entry.id, { userId: 'mcp' });
+            }
+            catch {
+                /* best effort — 不阻塞批量提交 */
+            }
             count++;
             successIds.push(entry.id);
             // 记录标题/指纹供后续去重检测

package/dist/lib/external/mcp/handlers/rescan-external.d.ts

@@ -0,0 +1,76 @@
+/**
+ * MCP Handler — autosnippet_rescan (增量知识更新)
+ *
+ * 保留已审核 Recipe，清理衍生缓存，全量/指定维度重新扫描，
+ * 新知识通过批量提交走正常的进化架构。
+ *
+ * 流程:
+ *   1. snapshotRecipes — 快照保留知识
+ *   2. rescanClean — 清理衍生缓存
+ *   3. Phase 1-4 全量分析
+ *   4. RecipeRelevanceAuditor — 证据验证 + 快速衰退
+ *   5. 构建 Mission Briefing（含 allRecipes + evolutionGuide）
+ *   6. 返回给 Agent 按维度执行: evolve → gap-fill → dimension_complete
+ *
+ * @module handlers/rescan-external
+ */
+import type { ServiceContainer } from '#inject/ServiceContainer.js';
+import type { RescanInput } from '#shared/schemas/mcp-tools.js';
+/** MCP handler context */
+interface McpContext {
+    container: ServiceContainer;
+    logger: {
+        info(msg: string, meta?: Record<string, unknown>): void;
+        warn(msg: string, meta?: Record<string, unknown>): void;
+    };
+    startedAt?: number;
+    [key: string]: unknown;
+}
+export declare function rescanExternal(ctx: McpContext, args: RescanInput): Promise<{
+    success: boolean;
+    errorCode: string | null;
+    message: string;
+    data: {
+        message: string;
+    } | null;
+    meta: {
+        source?: string | undefined;
+        responseTimeMs?: number | undefined;
+        version: string;
+        tool?: string | undefined;
+    };
+} | {
+    success: boolean;
+    errorCode: string | null;
+    message: string;
+    data: {
+        meta?: {
+            warnings?: string[];
+            responseSizeKB?: number;
+            [key: string]: unknown;
+        };
+        rescan: {
+            preservedRecipes: number;
+            cleanedTables: number;
+            cleanedFiles: number;
+            reason: string | null;
+        };
+        relevanceAudit: {
+            totalAudited: number;
+            healthy: number;
+            watch: number;
+            decay: number;
+            severe: number;
+            dead: number;
+            proposalsCreated: number;
+            immediateDeprecated: number;
+        };
+    } | null;
+    meta: {
+        source?: string | undefined;
+        responseTimeMs?: number | undefined;
+        version: string;
+        tool?: string | undefined;
+    };
+}>;
+export {};