autosnippet 3.3.0 → 3.3.3

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

@@ -133,6 +133,18 @@ export async function guardAuditFiles(ctx, args) {
             ...(result.crossFileViolations?.length
                 ? { crossFileViolations: result.crossFileViolations }
                 : {}),
+            // uncertain 消费链路 — 结构化上抛给 Agent
+            ...(result.capabilityReport
+                ? {
+                    capabilityReport: result.capabilityReport,
+                    uncertainSummary: {
+                        total: result.capabilityReport.uncertainResults.length,
+                        byLayer: _groupBy(result.capabilityReport.uncertainResults, 'layer'),
+                        byReason: _groupBy(result.capabilityReport.uncertainResults, 'reason'),
+                    },
+                    boundaries: result.capabilityReport.boundaries,
+                }
+                : {}),
         },
         meta: { tool: 'autosnippet_guard' },
     });
@@ -152,7 +164,7 @@ export async function guardAuditFiles(ctx, args) {
  * @param args { files?: string[] }
  */
 export async function guardReview(ctx, args) {
-    const { GuardCheckEngine, detectLanguage } = await import('#service/guard/GuardCheckEngine.js');
+    const { GuardCheckEngine } = await import('#service/guard/GuardCheckEngine.js');
     const projectRoot = resolveProjectRoot(ctx.container);
     // 轮次追踪（基于 projectRoot，不绑定 task）
     const round = (_reviewRounds.get(projectRoot) || 0) + 1;
@@ -203,16 +215,21 @@ export async function guardReview(ctx, args) {
     // 3. 创建引擎，注入 Enhancement Pack
     const engine = _getOrCreateEngine(ctx, GuardCheckEngine);
     await _injectEnhancementGuardRules(engine, ctx);
-    // 4. 逐文件检查
+    // 4. 逐文件检查（使用 auditFile 以捕获 uncertain）
     const results = [];
     let totalViolations = 0;
     let totalErrors = 0;
     let totalWarnings = 0;
+    const allUncertainResults = [];
     for (const fp of filePaths) {
         try {
             const code = await readFile(fp, 'utf8');
-            const lang = detectLanguage(fp);
-            const violations = engine.checkCode(code, lang, { filePath: fp });
+            const auditResult = engine.auditFile(fp, code);
+            const violations = auditResult.violations;
+            // 收集 uncertain
+            if (auditResult.uncertainResults?.length) {
+                allUncertainResults.push(...auditResult.uncertainResults);
+            }
             const fileSummary = {
                 total: violations.length,
                 errors: violations.filter((v) => v.severity === 'error').length,
@@ -242,7 +259,12 @@ export async function guardReview(ctx, args) {
                 }
                 return base;
             });
-            results.push({ filePath: fp, language: lang, violations: enriched, summary: fileSummary });
+            results.push({
+                filePath: fp,
+                language: auditResult.language,
+                violations: enriched,
+                summary: fileSummary,
+            });
         }
         catch (err) {
             results.push({
@@ -312,6 +334,17 @@ export async function guardReview(ctx, args) {
                 warnings: totalWarnings,
                 filesChecked: filePaths.length,
             },
+            // uncertain 消费链路 — 结构化上抛给 Agent
+            ...(allUncertainResults.length > 0
+                ? {
+                    uncertainSummary: {
+                        total: allUncertainResults.length,
+                        byLayer: _groupBy(allUncertainResults, 'layer'),
+                        byReason: _groupBy(allUncertainResults, 'reason'),
+                    },
+                    uncertainResults: allUncertainResults,
+                }
+                : {}),
         },
         message,
         meta: { tool: 'autosnippet_guard', mode: 'review' },
@@ -562,6 +595,15 @@ export async function scanProject(ctx, args) {
     });
 }
 // ─── 内部辅助 ─────────────────────────────────────────────
+/** 按字段值分组计数 */
+function _groupBy(arr, key) {
+    const counts = {};
+    for (const item of arr) {
+        const k = String(item[key] ?? 'unknown');
+        counts[k] = (counts[k] || 0) + 1;
+    }
+    return counts;
+}
 /**
  * 获取 DI 容器中的 GuardCheckEngine 单例，回退到新建实例
  * 优先复用 DI 单例以保持 externalRules / cache 的跨调用一致性
@@ -618,3 +660,195 @@ async function _injectEnhancementGuardRules(engine, ctx) {
         /* Enhancement registry not available — non-critical */
     }
 }
+/**
+ * 对所有 active rule Recipe 执行反向验证：
+ *   - 检查 coreCode 引用的符号是否还存在
+ *   - 检查 guard pattern 匹配率是否骤降
+ */
+export async function guardReverseAudit(ctx, args) {
+    const { ReverseGuard } = await import('#service/guard/ReverseGuard.js');
+    const { collectSourceFilesWithContent } = await import('#service/guard/SourceFileCollector.js');
+    const projectRoot = resolveProjectRoot(ctx.container);
+    // 尝试从 DI 获取，回退到新建
+    let reverseGuard;
+    try {
+        reverseGuard = ctx.container.get('reverseGuard');
+    }
+    catch {
+        const db = ctx.container.get('database');
+        reverseGuard = new ReverseGuard(db.getDb());
+    }
+    const maxFiles = args.maxFiles || 200;
+    const projectFiles = await collectSourceFilesWithContent(projectRoot, { maxFiles });
+    const results = reverseGuard.auditAllRules(projectFiles);
+    const drifts = reverseGuard.getDriftResults(results);
+    return envelope({
+        success: true,
+        data: {
+            totalRecipes: results.length,
+            healthy: results.filter((r) => r.recommendation === 'healthy').length,
+            investigate: results.filter((r) => r.recommendation === 'investigate').length,
+            decay: results.filter((r) => r.recommendation === 'decay').length,
+            drifts: drifts.map((d) => ({
+                recipeId: d.recipeId,
+                title: d.title,
+                recommendation: d.recommendation,
+                signals: d.signals,
+            })),
+            allResults: results.map((r) => ({
+                recipeId: r.recipeId,
+                title: r.title,
+                recommendation: r.recommendation,
+                signalCount: r.signals.length,
+            })),
+        },
+        meta: { tool: 'autosnippet_guard', operation: 'reverse_audit' },
+    });
+}
+/**
+ * 计算模块级 Guard 规则覆盖率矩阵
+ */
+export async function guardCoverageMatrix(ctx, _args) {
+    const { CoverageAnalyzer } = await import('#service/guard/CoverageAnalyzer.js');
+    const projectRoot = resolveProjectRoot(ctx.container);
+    // 尝试从 DI 获取，回退到新建
+    let analyzer;
+    try {
+        analyzer = ctx.container.get('coverageAnalyzer');
+    }
+    catch {
+        const db = ctx.container.get('database');
+        analyzer = new CoverageAnalyzer(db.getDb());
+    }
+    // 构建 moduleFiles 映射 — 从 Panorama 或目录结构推断
+    const moduleFiles = await _buildModuleFiles(ctx, projectRoot);
+    const matrix = analyzer.analyze(moduleFiles);
+    return envelope({
+        success: true,
+        data: {
+            overallCoverage: matrix.overallCoverage,
+            zeroModules: matrix.zeroModules,
+            lowModules: matrix.lowModules,
+            modules: matrix.modules,
+        },
+        meta: { tool: 'autosnippet_guard', operation: 'coverage_matrix' },
+    });
+}
+/**
+ * 生成 3D 合规报告（compliance + coverage + confidence）
+ * 包含完整 uncertain 消费数据
+ */
+export async function guardComplianceReport(ctx, _args) {
+    const { ComplianceReporter } = await import('#service/guard/ComplianceReporter.js');
+    const projectRoot = resolveProjectRoot(ctx.container);
+    // 尝试从 DI 获取，回退到新建
+    let reporter;
+    try {
+        reporter = ctx.container.get('complianceReporter');
+    }
+    catch {
+        const { GuardCheckEngine } = await import('#service/guard/GuardCheckEngine.js');
+        const engine = _getOrCreateEngine(ctx, GuardCheckEngine);
+        await _injectEnhancementGuardRules(engine, ctx);
+        // ComplianceReporter(engine, violationsStore, ruleLearner, exclusionManager, config)
+        let violationsStore = null;
+        let ruleLearner = null;
+        let exclusionManager = null;
+        try {
+            violationsStore = ctx.container.get('violationsStore');
+        }
+        catch {
+            /* optional */
+        }
+        try {
+            ruleLearner = ctx.container.get('ruleLearner');
+        }
+        catch {
+            /* optional */
+        }
+        try {
+            exclusionManager = ctx.container.get('exclusionManager');
+        }
+        catch {
+            /* optional */
+        }
+        reporter = new ComplianceReporter(engine, violationsStore, ruleLearner, exclusionManager);
+    }
+    const report = await reporter.generate(projectRoot);
+    return envelope({
+        success: true,
+        data: {
+            scores: {
+                compliance: report.complianceScore,
+                coverage: report.coverageScore,
+                confidence: report.confidenceScore,
+            },
+            qualityGate: report.qualityGate,
+            summary: report.summary,
+            uncertainSummary: report.uncertainSummary || null,
+            boundaries: report.boundaries || [],
+            topViolations: (report.topViolations || []).slice(0, 10),
+            trend: report.trend || null,
+        },
+        meta: { tool: 'autosnippet_guard', operation: 'compliance_report' },
+    });
+}
+/** 从 Panorama 或目录结构构建模块→文件映射 */
+async function _buildModuleFiles(ctx, projectRoot) {
+    const moduleFiles = new Map();
+    try {
+        const panorama = ctx.container.get('panoramaService');
+        const overview = await panorama.getOverview();
+        if (overview?.modules) {
+            for (const mod of overview.modules) {
+                if (mod.files?.length > 0) {
+                    moduleFiles.set(mod.name, mod.files);
+                }
+            }
+        }
+    }
+    catch {
+        /* PanoramaService not available */
+    }
+    if (moduleFiles.size === 0) {
+        const { readdirSync, existsSync } = await import('node:fs');
+        const srcDirs = ['Sources', 'BiliDili/Modules', 'src', 'lib'];
+        for (const dir of srcDirs) {
+            const fullDir = path.join(projectRoot, dir);
+            if (existsSync(fullDir)) {
+                for (const entry of readdirSync(fullDir, { withFileTypes: true })) {
+                    if (entry.isDirectory() && !entry.name.startsWith('.')) {
+                        const files = _walkSourceFiles(path.join(fullDir, entry.name));
+                        if (files.length > 0) {
+                            moduleFiles.set(entry.name, files);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return moduleFiles;
+}
+function _walkSourceFiles(dir) {
+    const files = [];
+    try {
+        const { readdirSync } = require('node:fs');
+        const walk = (d) => {
+            for (const e of readdirSync(d, { withFileTypes: true })) {
+                const fp = path.join(d, e.name);
+                if (e.isDirectory() && !e.name.startsWith('.')) {
+                    walk(fp);
+                }
+                else if (e.isFile() &&
+                    /\.(m|h|swift|mm|ts|js|py|java|kt|dart|rs|go|cs|rb)$/.test(e.name)) {
+                    files.push(fp);
+                }
+            }
+        };
+        walk(dir);
+    }
+    catch {
+        /* directory read error */
+    }
+    return files;
+}

package/dist/lib/external/mcp/handlers/knowledge.d.ts

@@ -75,33 +75,4 @@ export declare function knowledgeLifecycle(ctx: McpContext, args: {
         tool?: string | undefined;
     };
 }>;
-/**
- * 保存开发文档 (autosnippet_save_document)
- *
- * 精简入口：仅需 title + markdown。
- * 自动设置 knowledgeType='dev-document', kind='fact', source='agent'。
- * 不走 RecipeReadiness 检查（文档无需 doClause/trigger）。
- * 支持 autoApprove — 文档直接进入 active 状态。
- */
-export declare function saveDocument(ctx: McpContext, args: {
-    title?: string;
-    markdown?: string;
-    description?: string;
-    client_id?: string;
-    source?: string;
-    scope?: string;
-    tags?: string[];
-    [key: string]: unknown;
-}): Promise<{
-    success: boolean;
-    errorCode: string | null;
-    message: string;
-    data: unknown;
-    meta: {
-        source?: string | undefined;
-        responseTimeMs?: number | undefined;
-        version: string;
-        tool?: string | undefined;
-    };
-}>;
 export {};

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

@@ -258,80 +258,5 @@ export async function knowledgeLifecycle(ctx, args) {
         meta: { tool: 'autosnippet_knowledge_lifecycle' },
     });
 }
-// ─── 内部辅助 ──────────────────────────────────────────────
-/**
- * 保存开发文档 (autosnippet_save_document)
- *
- * 精简入口：仅需 title + markdown。
- * 自动设置 knowledgeType='dev-document', kind='fact', source='agent'。
- * 不走 RecipeReadiness 检查（文档无需 doClause/trigger）。
- * 支持 autoApprove — 文档直接进入 active 状态。
- */
-export async function saveDocument(ctx, args) {
-    if (!args.title || !args.title.trim()) {
-        throw new Error('title 必填');
-    }
-    if (!args.markdown || !args.markdown.trim()) {
-        throw new Error('markdown 必填');
-    }
-    // 限流
-    const blocked = await _checkRateLimit('autosnippet_save_document', args.client_id, ctx.container);
-    if (blocked) {
-        return blocked;
-    }
-    const service = ctx.container.get('knowledgeService');
-    const data = {
-        title: args.title.trim(),
-        description: args.description || '',
-        knowledgeType: 'dev-document',
-        kind: 'fact',
-        source: args.source || 'agent',
-        scope: args.scope || 'project-specific',
-        tags: args.tags || [],
-        content: {
-            markdown: args.markdown,
-            pattern: '',
-        },
-        // 文档不需要 Cursor Delivery 字段
-        trigger: '',
-        doClause: '',
-        dontClause: '',
-        whenClause: '',
-        topicHint: '',
-        coreCode: '',
-        // 基础推理
-        reasoning: {
-            whyStandard: 'Agent development document — preserved for team knowledge',
-            sources: ['agent'],
-            confidence: 0.8,
-        },
-    };
-    // ── UnifiedValidator 校验（自动检测 document 模式）──
-    const validator = new UnifiedValidator();
-    const vr = validator.validate(data, { skipUniqueness: true });
-    if (!vr.pass) {
-        throw new Error(`文档校验失败: ${vr.errors.join('; ')}`);
-    }
-    const entry = await service.create(data, { userId: 'mcp' });
-    // 自动发布（dev-document 不需要人工审核）
-    try {
-        await service.publish(entry.id, { userId: 'mcp' });
-    }
-    catch {
-        // 发布失败保持 pending — 非阻塞
-    }
-    return envelope({
-        success: true,
-        data: {
-            id: entry.id,
-            lifecycle: 'active',
-            title: entry.title,
-            kind: 'fact',
-            knowledgeType: 'dev-document',
-        },
-        message: `文档「${entry.title}」已保存到知识库。`,
-        meta: { tool: 'autosnippet_save_document' },
-    });
-}
-// ─── 内部辅助 ──────────────────────────────────────────────
+// ─── (已删除: saveDocument — 已合并到 submit_knowledge 统一管线) ──
 // ─── (已删除: _toReadinessInput — 统一使用 UnifiedValidator) ──

package/dist/lib/external/mcp/handlers/panorama.d.ts

@@ -0,0 +1,36 @@
+/**
+ * MCP Handler — autosnippet_panorama
+ *
+ * Project panorama query tool with 8 operations:
+ *   overview — project skeleton + layers + module roles
+ *   module   — single module detail + neighbors + recipes + file groups
+ *   gaps     — knowledge gaps (code without Recipes)
+ *   health   — panorama health (coverage + coupling + cycles)
+ *   governance_cycle       — full metabolism cycle (contradiction + redundancy + decay)
+ *   decay_report           — decay assessment report
+ *   staging_check          — staging entry check + auto-publish
+ *   enhancement_suggestions — usage-data-based enhancement suggestions
+ *
+ * All read-only except governance_cycle and staging_check (which perform state transitions).
+ */
+import type { McpContext } from './types.js';
+interface PanoramaArgs {
+    operation?: string;
+    module?: string;
+}
+/**
+ * autosnippet_panorama — unified panorama query
+ */
+export declare function panoramaHandler(ctx: McpContext, args: PanoramaArgs): Promise<{
+    success: boolean;
+    errorCode: string | null;
+    message: string;
+    data: unknown;
+    meta: {
+        source?: string | undefined;
+        responseTimeMs?: number | undefined;
+        version: string;
+        tool?: string | undefined;
+    };
+}>;
+export {};

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

@@ -0,0 +1,156 @@
+/**
+ * MCP Handler — autosnippet_panorama
+ *
+ * Project panorama query tool with 8 operations:
+ *   overview — project skeleton + layers + module roles
+ *   module   — single module detail + neighbors + recipes + file groups
+ *   gaps     — knowledge gaps (code without Recipes)
+ *   health   — panorama health (coverage + coupling + cycles)
+ *   governance_cycle       — full metabolism cycle (contradiction + redundancy + decay)
+ *   decay_report           — decay assessment report
+ *   staging_check          — staging entry check + auto-publish
+ *   enhancement_suggestions — usage-data-based enhancement suggestions
+ *
+ * All read-only except governance_cycle and staging_check (which perform state transitions).
+ */
+import { envelope } from '../envelope.js';
+/**
+ * autosnippet_panorama — unified panorama query
+ */
+export async function panoramaHandler(ctx, args) {
+    const op = args.operation || 'overview';
+    const panoramaService = ctx.container.get('panoramaService');
+    if (!panoramaService) {
+        return envelope({
+            success: false,
+            message: 'Panorama service not initialized',
+            meta: { tool: 'autosnippet_panorama' },
+        });
+    }
+    // Auto-ensure data is ready (triggers built-in scan when no data exists)
+    await panoramaService.ensureData();
+    switch (op) {
+        case 'overview': {
+            const overview = panoramaService.getOverview();
+            return envelope({
+                success: true,
+                data: overview,
+                meta: { tool: 'autosnippet_panorama' },
+            });
+        }
+        case 'module': {
+            const moduleName = args.module;
+            if (!moduleName) {
+                return envelope({
+                    success: false,
+                    message: 'operation=module requires the "module" parameter (module name)',
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            const detail = panoramaService.getModule(moduleName);
+            if (!detail) {
+                return envelope({
+                    success: false,
+                    message: `Module not found: ${moduleName}`,
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            return envelope({
+                success: true,
+                data: detail,
+                meta: { tool: 'autosnippet_panorama' },
+            });
+        }
+        case 'gaps': {
+            const gaps = panoramaService.getGaps();
+            return envelope({
+                success: true,
+                data: { gaps },
+                meta: { tool: 'autosnippet_panorama' },
+            });
+        }
+        case 'health': {
+            const health = panoramaService.getHealth();
+            return envelope({
+                success: true,
+                data: health,
+                meta: { tool: 'autosnippet_panorama' },
+            });
+        }
+        default:
+            // ── Governance operations (independent of panoramaService) ──
+            return handleGovernanceOps(ctx, op);
+    }
+}
+/* ────────────────────── Governance Handlers ────────────────────── */
+async function handleGovernanceOps(ctx, op) {
+    switch (op) {
+        case 'governance_cycle': {
+            const metabolism = ctx.container.get('knowledgeMetabolism');
+            if (!metabolism) {
+                return envelope({
+                    success: false,
+                    message: 'Governance service not initialized (knowledgeMetabolism not registered)',
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            const report = metabolism.runFullCycle();
+            return envelope({
+                success: true,
+                data: report,
+                meta: { tool: 'autosnippet_panorama', operation: 'governance_cycle' },
+            });
+        }
+        case 'decay_report': {
+            const decayDetector = ctx.container.get('decayDetector');
+            if (!decayDetector) {
+                return envelope({
+                    success: false,
+                    message: 'Decay detector not initialized (decayDetector not registered)',
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            const results = decayDetector.scanAll();
+            return envelope({
+                success: true,
+                data: { results },
+                meta: { tool: 'autosnippet_panorama', operation: 'decay_report' },
+            });
+        }
+        case 'staging_check': {
+            const stagingManager = ctx.container.get('stagingManager');
+            if (!stagingManager) {
+                return envelope({
+                    success: false,
+                    message: 'Staging manager not initialized (stagingManager not registered)',
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            const checkResult = stagingManager.checkAndPromote();
+            const currentStaging = stagingManager.listStaging();
+            return envelope({
+                success: true,
+                data: { checkResult, currentStaging },
+                meta: { tool: 'autosnippet_panorama', operation: 'staging_check' },
+            });
+        }
+        case 'enhancement_suggestions': {
+            const suggester = ctx.container.get('enhancementSuggester');
+            if (!suggester) {
+                return envelope({
+                    success: false,
+                    message: 'Enhancement suggester not initialized (enhancementSuggester not registered)',
+                    meta: { tool: 'autosnippet_panorama' },
+                });
+            }
+            const suggestions = suggester.analyzeAll();
+            return envelope({
+                success: true,
+                data: { suggestions },
+                meta: { tool: 'autosnippet_panorama', operation: 'enhancement_suggestions' },
+            });
+        }
+        default:
+            throw new Error(`Unknown panorama operation: ${op}. Expected: overview, module, gaps, health, governance_cycle, decay_report, staging_check, enhancement_suggestions`);
+    }
+}

package/dist/lib/external/mcp/handlers/system.d.ts

@@ -1,6 +1,6 @@
 /**
  * MCP Handlers — 系统类
- * health, capabilities
+ * health
  */
 import type { KnowledgeBaseStats, McpContext } from './types.js';
 export declare function health(ctx: McpContext): Promise<{
@@ -12,7 +12,7 @@ export declare function health(ctx: McpContext): Promise<{
         issues?: string[] | undefined;
         session?: {
             id: string;
-            readyCalled: boolean;
+            intentPhase: "active" | "idle" | "ended";
             toolCallCount: number;
             toolsUsed: string[];
             durationMs: number;
@@ -40,55 +40,3 @@ export declare function health(ctx: McpContext): Promise<{
         tool?: string | undefined;
     };
 }>;
-export declare function capabilities(): {
-    success: boolean;
-    errorCode: string | null;
-    message: string;
-    data: {
-        count: number;
-        tier: string;
-        categoryGuide: {
-            system: string;
-            search: string;
-            browse: string;
-            graph: string;
-            structure: string;
-            submit: string;
-            guard: string;
-            skill: string;
-            bootstrap: string;
-            admin: string;
-        };
-        byCategory: Record<string, string[]>;
-        tools: {
-            name: string;
-            tier: string;
-            description: string;
-            category: string;
-            gatewayGated: boolean;
-            params: {
-                description?: {} | undefined;
-                enum?: {} | undefined;
-                default?: {} | null | undefined;
-                name: string;
-                type: {};
-                required: boolean;
-            }[];
-        }[];
-        workflows: ({
-            name: string;
-            steps: string[];
-            tips: string;
-        } | {
-            name: string;
-            steps: string[];
-            tips?: undefined;
-        })[];
-    } | null;
-    meta: {
-        source?: string | undefined;
-        responseTimeMs?: number | undefined;
-        version: string;
-        tool?: string | undefined;
-    };
-};