mcp-probe-kit 3.0.18 → 3.0.21

package/build/tools/memorize_asset.js

@@ -42,6 +42,17 @@ export async function memorizeAsset(args) {
         if (!client.isEnabled()) {
             return okStructured('记忆服务未开启，已跳过沉淀。', { enabled: false, stored: false });
         }
+        const warnings = [];
+        if (type === 'bugfix') {
+            const requiredSections = ['【现象】', '【根因】', '【修复】'];
+            const missing = requiredSections.filter((section) => !content.includes(section));
+            if (missing.length > 0) {
+                warnings.push(`建议 content 包含 ${missing.join('、')}，便于跨仓库检索与复用`);
+            }
+        }
+        if (sourceProject || sourcePath) {
+            warnings.push('跨仓库共享记忆时请勿依赖 source_project/source_path；路径请写入 content 正文（可选）');
+        }
         const asset = await client.upsertAsset({
             name,
             type,
@@ -58,6 +69,7 @@ export async function memorizeAsset(args) {
             enabled: true,
             stored: true,
             asset,
+            warnings: warnings.length > 0 ? warnings : undefined,
         });
     }
     catch (error) {

package/build/tools/scan_and_extract_patterns.js

@@ -108,21 +108,22 @@ function summarizeContent(content, maxChars = 200) {
         .trim()
         .slice(0, maxChars);
 }
-function buildPattern(content, filePath, projectName) {
+function buildPattern(content, filePath) {
     const normalized = content.trim();
     const candidateNames = collectCandidateNames(normalized);
     const primaryName = candidateNames[0] || (filePath ? path.basename(filePath) : 'snippet');
     const type = detectPatternType(normalized, filePath);
     const summary = summarizeContent(normalized);
+    const fileHint = filePath ? `（摘录自 ${filePath}）` : '';
     return {
         name: primaryName,
         type,
-        description: filePath ? `从 ${filePath} 提取的可复用模式` : '从代码片段提取的可复用模式',
+        description: filePath
+            ? `从 ${filePath} 提取的可复用模式${fileHint}`
+            : '从代码片段提取的可复用模式',
         summary,
         content: normalized,
         tags: inferTags(normalized, filePath),
-        sourcePath: filePath || undefined,
-        sourceProject: projectName || undefined,
         confidence: filePath ? 0.62 : 0.55,
         candidateNames,
     };
@@ -271,7 +272,6 @@ export async function scanAndExtractPatterns(args) {
         });
         const content = getString(parsed.content);
         const filePath = getString(parsed.file_path);
-        const projectName = getString(parsed.project_name);
         const directoryPath = getString(parsed.directory_path);
         const projectRoot = resolveWorkspaceRoot(getString(parsed.project_root));
         const maxFiles = Math.max(1, Math.min(200, getNumber(parsed.max_files, 30)));
@@ -282,7 +282,7 @@ export async function scanAndExtractPatterns(args) {
                 .map((item) => item.startsWith('.') ? item.toLowerCase() : `.${item.toLowerCase()}`)
             : DEFAULT_INCLUDE_EXTENSIONS);
         if (content) {
-            const pattern = buildPattern(content, filePath, projectName || undefined);
+            const pattern = buildPattern(content, filePath);
             return okStructured(`已提取 1 个候选模式${filePath ? `: ${filePath}` : ''}`, {
                 mode: 'single',
                 patterns: [pattern],
@@ -331,7 +331,7 @@ export async function scanAndExtractPatterns(args) {
                 continue;
             }
             const relativePath = toRelativePath(absoluteFile, projectRoot).replace(/\\/g, '/');
-            patterns.push(buildPattern(normalized, relativePath, projectName || path.basename(projectRoot)));
+            patterns.push(buildPattern(normalized, relativePath));
         }
         return okStructured(`已扫描 ${files.length} 个文件，提取 ${patterns.length} 个候选模式`, {
             mode: 'directory',

package/build/tools/search_memory.d.ts

@@ -0,0 +1,7 @@
+export declare function searchMemory(args: unknown): Promise<import("../lib/response.js").ToolResponse | {
+    content: Array<{
+        type: string;
+        text: string;
+    }>;
+    isError: true;
+}>;

package/build/tools/search_memory.js

@@ -0,0 +1,57 @@
+import { parseArgs, getString, getNumber } from '../utils/parseArgs.js';
+import { okStructured } from '../lib/response.js';
+import { createMemoryClient } from '../lib/memory-client.js';
+import { shouldShowSourceInSearch } from '../lib/memory-orchestration.js';
+import { getMemoryConfig } from '../lib/memory-config.js';
+import { handleToolError } from '../utils/error-handler.js';
+export async function searchMemory(args) {
+    try {
+        const parsed = parseArgs(args, {
+            defaultValues: {
+                query: '',
+                type: '',
+                limit: 0,
+            },
+        });
+        const query = getString(parsed.query);
+        if (!query) {
+            throw new Error('缺少必填参数: query');
+        }
+        const client = createMemoryClient();
+        if (!client.isEnabled()) {
+            return okStructured('记忆服务未开启，无法检索。', {
+                enabled: false,
+                results: [],
+            });
+        }
+        const config = getMemoryConfig();
+        const limit = getNumber(parsed.limit, config.searchLimit);
+        const typeFilter = getString(parsed.type);
+        const tags = Array.isArray(parsed.tags)
+            ? parsed.tags.filter((item) => typeof item === 'string')
+            : [];
+        const results = await client.search(query, {
+            limit,
+            preferTypes: typeFilter ? [typeFilter] : [],
+            preferTags: tags,
+        });
+        const items = results.map((item) => ({
+            id: item.id,
+            score: item.score,
+            name: item.name,
+            type: item.type,
+            summary: item.summary,
+            tags: item.tags,
+            sourcePath: shouldShowSourceInSearch(item, config) ? item.sourcePath : undefined,
+        }));
+        return okStructured(results.length > 0 ? `找到 ${results.length} 条相关记忆` : '未找到相关记忆', {
+            enabled: true,
+            query,
+            count: results.length,
+            results: items,
+        });
+    }
+    catch (error) {
+        return handleToolError(error, 'search_memory');
+    }
+}