mcp-probe-kit 3.0.16 → 3.0.18

package/build/index.js

@@ -5,7 +5,7 @@ import { InMemoryTaskMessageQueue, InMemoryTaskStore, } from "@modelcontextproto
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ProgressNotificationSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { initProject, gencommit, codeReview, codeInsight, gentest, refactor, initProjectContext, addFeature, fixBug, estimate, startFeature, startBugfix, startOnboard, startRalph, interview, askUser, uiDesignSystem, uiSearch, syncUiData, startUi, startProduct, gitWorkReport } from "./tools/index.js";
+import { initProject, gencommit, codeReview, codeInsight, gentest, refactor, initProjectContext, addFeature, fixBug, estimate, startFeature, startBugfix, startOnboard, startRalph, interview, askUser, uiDesignSystem, uiSearch, syncUiData, startUi, startProduct, gitWorkReport, readMemoryAsset, memorizeAsset, scanAndExtractPatterns, cursorListConversations, cursorSearchConversations, cursorReadConversation } from "./tools/index.js";
 import { VERSION, NAME } from "./version.js";
 import { allToolSchemas } from "./schemas/index.js";
 import { filterTools, getToolsetFromEnv } from "./lib/toolset-manager.js";
@@ -459,6 +459,18 @@ async function executeTool(name, args, context) {
             return await startProduct((args ?? {}), context);
         case "git_work_report":
             return await gitWorkReport(args);
+        case "read_memory_asset":
+            return await readMemoryAsset(args);
+        case "memorize_asset":
+            return await memorizeAsset(args);
+        case "scan_and_extract_patterns":
+            return await scanAndExtractPatterns(args);
+        case "cursor_list_conversations":
+            return await cursorListConversations(args);
+        case "cursor_search_conversations":
+            return await cursorSearchConversations(args);
+        case "cursor_read_conversation":
+            return await cursorReadConversation(args);
         default:
             throw new Error(`未知工具: ${name}`);
     }

package/build/lib/__tests__/memory-client.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lib/__tests__/memory-client.unit.test.js

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { buildMemoryContentHashes, MemoryClient, normalizeContentForHash, } from '../memory-client.js';
+const originalFetch = globalThis.fetch;
+afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+    globalThis.fetch = originalFetch;
+});
+describe('memory-client 去重逻辑', () => {
+    test('归一化 hash 忽略换行风格、行尾空白和多余空行', () => {
+        const a = 'export const x = 1;  \r\n\r\n\r\n';
+        const b = 'export const x = 1;\n\n';
+        expect(normalizeContentForHash(a)).toBe('export const x = 1;');
+        expect(normalizeContentForHash(b)).toBe('export const x = 1;');
+        expect(buildMemoryContentHashes(a).normalizedContentHash).toBe(buildMemoryContentHashes(b).normalizedContentHash);
+    });
+    test('重复内容二次沉淀时直接复用已有资产', async () => {
+        vi.stubEnv('MEMORY_QDRANT_URL', 'http://127.0.0.1:50008');
+        vi.stubEnv('MEMORY_EMBEDDING_URL', 'http://127.0.0.1:11434/api/embeddings');
+        vi.stubEnv('MEMORY_EMBEDDING_MODEL', 'nomic-embed-text');
+        const existingAsset = {
+            id: 'existing-asset-id',
+            name: 'ExistingAsset',
+            type: 'code',
+            description: '已有资产',
+            summary: '重复内容直接复用',
+            content: 'export const x = 1;\n',
+            tags: ['memory'],
+            confidence: 0.7,
+            contentHash: 'raw-hash',
+            normalizedContentHash: buildMemoryContentHashes('export const x = 1;\n').normalizedContentHash,
+            createdAt: '2026-01-01T00:00:00.000Z',
+            updatedAt: '2026-01-01T00:00:00.000Z',
+        };
+        const fetchMock = vi.fn(async (input, init) => {
+            const url = String(input);
+            if (url.endsWith('/api/embeddings')) {
+                return new Response(JSON.stringify({ embedding: [0.1, 0.2, 0.3] }), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            if (url.endsWith('/collections/mcp_probe_memory') && !init?.method) {
+                return new Response('', { status: 200 });
+            }
+            if (url.endsWith('/points/scroll')) {
+                return new Response(JSON.stringify({
+                    result: {
+                        points: [
+                            {
+                                id: existingAsset.id,
+                                payload: existingAsset,
+                            },
+                        ],
+                    },
+                }), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            if (url.includes('/points?wait=true')) {
+                return new Response(JSON.stringify({ status: 'ok' }), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/json' },
+                });
+            }
+            throw new Error(`unexpected fetch: ${url}`);
+        });
+        globalThis.fetch = fetchMock;
+        const client = new MemoryClient();
+        const result = await client.upsertAsset({
+            name: 'NewAsset',
+            type: 'code',
+            description: '新资产',
+            summary: '和已有资产内容一致',
+            content: 'export const x = 1;   \r\n\r\n',
+            tags: ['memory'],
+        });
+        expect(result.id).toBe(existingAsset.id);
+        expect(result.normalizedContentHash).toBe(existingAsset.normalizedContentHash);
+        expect(fetchMock.mock.calls.some(([url]) => String(url).includes('/points?wait=true'))).toBe(false);
+    });
+});

package/build/lib/__tests__/memory-config.unit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/lib/__tests__/memory-config.unit.test.js

@@ -0,0 +1,33 @@
+import { afterEach, describe, expect, test, vi } from 'vitest';
+import { getMemoryConfig, isMemoryEnabled, isMemoryReadEnabled } from '../memory-config.js';
+afterEach(() => {
+    vi.unstubAllEnvs();
+});
+describe('memory-config 单元测试', () => {
+    test('默认未配置时记忆读写均关闭', () => {
+        vi.stubEnv('MEMORY_QDRANT_URL', '');
+        vi.stubEnv('MEMORY_EMBEDDING_URL', '');
+        vi.stubEnv('MEMORY_EMBEDDING_MODEL', '');
+        const config = getMemoryConfig();
+        expect(isMemoryEnabled(config)).toBe(false);
+        expect(isMemoryReadEnabled(config)).toBe(false);
+    });
+    test('仅配置 qdrant 时只开启只读能力', () => {
+        vi.stubEnv('MEMORY_QDRANT_URL', 'http://127.0.0.1:50008');
+        vi.stubEnv('MEMORY_EMBEDDING_URL', '');
+        vi.stubEnv('MEMORY_EMBEDDING_MODEL', '');
+        const config = getMemoryConfig();
+        expect(isMemoryReadEnabled(config)).toBe(true);
+        expect(isMemoryEnabled(config)).toBe(false);
+    });
+    test('qdrant、embedding url 和 model 齐全时开启记忆服务', () => {
+        vi.stubEnv('MEMORY_QDRANT_URL', 'http://127.0.0.1:50008/');
+        vi.stubEnv('MEMORY_EMBEDDING_URL', 'http://127.0.0.1:11434/api/embeddings/');
+        vi.stubEnv('MEMORY_EMBEDDING_MODEL', 'nomic-embed-text');
+        const config = getMemoryConfig();
+        expect(config.qdrantUrl).toBe('http://127.0.0.1:50008');
+        expect(config.embeddingUrl).toBe('http://127.0.0.1:11434/api/embeddings');
+        expect(isMemoryReadEnabled(config)).toBe(true);
+        expect(isMemoryEnabled(config)).toBe(true);
+    });
+});

package/build/lib/cursor-history-client.d.ts

@@ -0,0 +1,54 @@
+export interface CursorConversationSummary {
+    composerId: string;
+    name: string;
+    createdAt?: number;
+    lastUpdatedAt?: number;
+    workspaceId?: string;
+    workspacePath?: string;
+    mode?: string;
+    contextUsagePercent?: number;
+    subtitle?: string;
+    isArchived?: boolean;
+    source: 'composerHeaders';
+}
+export interface CursorConversationMessage {
+    bubbleId: string;
+    type: number;
+    text: string;
+    createdAt?: string;
+    requestId?: string;
+}
+export interface CursorConversationDetail {
+    composerId: string;
+    messages: CursorConversationMessage[];
+}
+export interface CursorHistorySearchResult {
+    composerId: string;
+    conversationName: string;
+    bubbleId: string;
+    type: number;
+    text: string;
+    createdAt?: string;
+    requestId?: string;
+}
+export declare class CursorHistoryClient {
+    private withDatabase;
+    private loadConversationIndex;
+    listConversations(params?: {
+        titleQuery?: string;
+        workspaceQuery?: string;
+        includeArchived?: boolean;
+        limit?: number;
+    }): Promise<CursorConversationSummary[]>;
+    searchHistory(params: {
+        query: string;
+        composerId?: string;
+        limit?: number;
+    }): Promise<CursorHistorySearchResult[]>;
+    readConversation(params: {
+        composerId: string;
+        limit?: number;
+        includeEmpty?: boolean;
+    }): Promise<CursorConversationDetail>;
+}
+export declare function createCursorHistoryClient(): CursorHistoryClient;

package/build/lib/cursor-history-client.js

@@ -0,0 +1,240 @@
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import sqlite3 from 'sqlite3';
+import { createToolError } from '../utils/error-handler.js';
+function parseJson(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function fileExists(filePath) {
+    try {
+        return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function resolveCursorGlobalDbPath() {
+    const appData = process.env.APPDATA?.trim();
+    const homeDir = os.homedir();
+    const candidates = [
+        appData ? path.join(appData, 'Cursor', 'User', 'globalStorage', 'state.vscdb') : '',
+        path.join(homeDir, '.config', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
+        path.join(homeDir, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
+    ].filter(Boolean);
+    const hit = candidates.find(fileExists);
+    if (!hit) {
+        throw createToolError('未找到 Cursor 全局状态库 state.vscdb', undefined, {
+            candidates,
+        });
+    }
+    return hit;
+}
+function openDatabase(dbPath) {
+    return new Promise((resolve, reject) => {
+        const db = new sqlite3.Database(dbPath, sqlite3.OPEN_READONLY, (error) => {
+            if (error) {
+                reject(createToolError(`打开 Cursor 数据库失败: ${error.message}`, error, { dbPath }));
+                return;
+            }
+            resolve(db);
+        });
+    });
+}
+function closeDatabase(db) {
+    return new Promise((resolve, reject) => {
+        db.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function allRows(db, sql, params = []) {
+    return new Promise((resolve, reject) => {
+        db.all(sql, params, (error, rows) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve((rows ?? []));
+        });
+    });
+}
+function getRow(db, sql, params = []) {
+    return new Promise((resolve, reject) => {
+        db.get(sql, params, (error, row) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(row);
+        });
+    });
+}
+function asString(value) {
+    return typeof value === 'string' ? value : '';
+}
+function asNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function asBoolean(value) {
+    return typeof value === 'boolean' ? value : undefined;
+}
+function extractConversationsFromHeaders(payload) {
+    const items = payload?.allComposers ?? [];
+    return items
+        .filter((item) => item?.type === 'head')
+        .map((item) => {
+        const workspace = item.workspaceIdentifier ?? {};
+        const uri = workspace.uri ?? {};
+        return {
+            composerId: asString(item.composerId),
+            name: asString(item.name),
+            createdAt: asNumber(item.createdAt),
+            lastUpdatedAt: asNumber(item.lastUpdatedAt),
+            workspaceId: asString(workspace.id) || undefined,
+            workspacePath: asString(uri.fsPath) || undefined,
+            mode: asString(item.unifiedMode) || undefined,
+            contextUsagePercent: asNumber(item.contextUsagePercent),
+            subtitle: asString(item.subtitle) || undefined,
+            isArchived: asBoolean(item.isArchived) ?? false,
+            source: 'composerHeaders',
+        };
+    });
+}
+function extractBubbleId(key) {
+    const parts = key.split(':');
+    return parts[parts.length - 1] || key;
+}
+function extractComposerId(key) {
+    const parts = key.split(':');
+    return parts.length >= 3 ? parts[1] || '' : '';
+}
+export class CursorHistoryClient {
+    async withDatabase(runner) {
+        const dbPath = resolveCursorGlobalDbPath();
+        const db = await openDatabase(dbPath);
+        try {
+            return await runner(db);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                throw createToolError(`读取 Cursor 历史失败: ${error.message}`, error, { dbPath });
+            }
+            throw error;
+        }
+        finally {
+            await closeDatabase(db).catch(() => undefined);
+        }
+    }
+    async loadConversationIndex(db) {
+        const row = await getRow(db, "select key, value from ItemTable where key = ?", ['composer.composerHeaders']);
+        const payload = parseJson(row?.value);
+        return extractConversationsFromHeaders(payload);
+    }
+    async listConversations(params = {}) {
+        return this.withDatabase(async (db) => {
+            const titleQuery = (params.titleQuery ?? '').trim().toLowerCase();
+            const workspaceQuery = (params.workspaceQuery ?? '').trim().toLowerCase();
+            const includeArchived = params.includeArchived ?? false;
+            const limit = Math.max(1, Math.min(params.limit ?? 20, 200));
+            const conversations = await this.loadConversationIndex(db);
+            return conversations
+                .filter((item) => includeArchived || !item.isArchived)
+                .filter((item) => !titleQuery || item.name.toLowerCase().includes(titleQuery))
+                .filter((item) => !workspaceQuery || (item.workspacePath ?? '').toLowerCase().includes(workspaceQuery))
+                .sort((a, b) => (b.lastUpdatedAt ?? 0) - (a.lastUpdatedAt ?? 0))
+                .slice(0, limit);
+        });
+    }
+    async searchHistory(params) {
+        return this.withDatabase(async (db) => {
+            const query = (params.query ?? '').trim().toLowerCase();
+            if (!query) {
+                throw new Error('缺少 query');
+            }
+            const limit = Math.max(1, Math.min(params.limit ?? 20, 200));
+            const composerId = (params.composerId ?? '').trim();
+            const index = await this.loadConversationIndex(db);
+            const names = new Map(index.map((item) => [item.composerId, item.name]));
+            const rows = await allRows(db, 'select key, value from cursorDiskKV where key like ?', [composerId ? `bubbleId:${composerId}:%` : 'bubbleId:%']);
+            const matches = rows
+                .map((row) => {
+                const parsed = parseJson(row.value);
+                if (!parsed) {
+                    return null;
+                }
+                const text = asString(parsed.text);
+                const requestId = asString(parsed.requestId);
+                const haystack = `${row.key}\n${text}\n${requestId}`.toLowerCase();
+                if (!haystack.includes(query)) {
+                    return null;
+                }
+                const currentComposerId = extractComposerId(row.key);
+                return {
+                    composerId: currentComposerId,
+                    conversationName: names.get(currentComposerId) ?? '',
+                    bubbleId: extractBubbleId(row.key),
+                    type: asNumber(parsed.type) ?? 0,
+                    text,
+                    createdAt: asString(parsed.createdAt) || undefined,
+                    requestId: requestId || undefined,
+                };
+            })
+                .filter((item) => item !== null)
+                .sort((a, b) => (b.createdAt ?? '').localeCompare(a.createdAt ?? ''))
+                .slice(0, limit);
+            return matches;
+        });
+    }
+    async readConversation(params) {
+        return this.withDatabase(async (db) => {
+            const composerId = (params.composerId ?? '').trim();
+            if (!composerId) {
+                throw new Error('缺少 composer_id');
+            }
+            const limit = Math.max(1, Math.min(params.limit ?? 200, 2000));
+            const includeEmpty = params.includeEmpty ?? false;
+            const rows = await allRows(db, 'select key, value from cursorDiskKV where key like ?', [`bubbleId:${composerId}:%`]);
+            const messages = rows
+                .map((row) => {
+                const parsed = parseJson(row.value);
+                if (!parsed) {
+                    return null;
+                }
+                const text = asString(parsed.text);
+                if (!includeEmpty && !text) {
+                    return null;
+                }
+                return {
+                    bubbleId: extractBubbleId(row.key),
+                    type: asNumber(parsed.type) ?? 0,
+                    text,
+                    createdAt: asString(parsed.createdAt) || undefined,
+                    requestId: asString(parsed.requestId) || undefined,
+                };
+            })
+                .filter((item) => item !== null)
+                .sort((a, b) => (a.createdAt ?? '').localeCompare(b.createdAt ?? ''))
+                .slice(0, limit);
+            return {
+                composerId,
+                messages,
+            };
+        });
+    }
+}
+export function createCursorHistoryClient() {
+    return new CursorHistoryClient();
+}

package/build/lib/gitnexus-bridge.js

@@ -5,6 +5,7 @@ import spawn from "cross-spawn";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { resolveWorkspaceRoot } from "./workspace-root.js";
 import { isAbortError, throwIfAborted, } from "./tool-execution-context.js";
 const DEFAULT_CONNECT_TIMEOUT_MS = readIntEnv("MCP_GITNEXUS_CONNECT_TIMEOUT_MS", 12000);
 const DEFAULT_CALL_TIMEOUT_MS = readIntEnv("MCP_GITNEXUS_TIMEOUT_MS", 20000);
@@ -82,15 +83,12 @@ function resolvePreferredRepoName(requestedRepo) {
     return undefined;
 }
 function resolveRequestedProjectRoot(projectRoot) {
-    const requested = projectRoot?.trim();
-    if (requested) {
-        return path.resolve(requested);
-    }
-    return path.resolve(process.cwd());
+    return resolveWorkspaceRoot(projectRoot);
 }
-function inferCandidateRepoNames(baseDir = process.cwd()) {
+function inferCandidateRepoNames(baseDir) {
+    const resolvedBaseDir = resolveWorkspaceRoot(baseDir);
     const candidates = [];
-    const pkgPath = path.join(baseDir, "package.json");
+    const pkgPath = path.join(resolvedBaseDir, "package.json");
     try {
         if (fs.existsSync(pkgPath)) {
             const parsed = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
@@ -103,7 +101,7 @@ function inferCandidateRepoNames(baseDir = process.cwd()) {
     catch {
         // ignore parse failure
     }
-    const base = path.basename(baseDir).trim();
+    const base = path.basename(resolvedBaseDir).trim();
     if (base) {
         candidates.push(base);
     }

package/build/lib/memory-client.d.ts

@@ -0,0 +1,61 @@
+import { type MemoryConfig } from './memory-config.js';
+export interface MemoryAsset {
+    id: string;
+    name: string;
+    type: string;
+    description: string;
+    summary: string;
+    content: string;
+    tags: string[];
+    confidence: number;
+    sourceProject?: string;
+    sourcePath?: string;
+    usage?: string;
+    contentHash?: string;
+    normalizedContentHash?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface MemorySearchResult {
+    id: string;
+    score: number;
+    name: string;
+    type: string;
+    description: string;
+    summary: string;
+    tags: string[];
+    sourcePath?: string;
+}
+export declare function normalizeContentForHash(content: string): string;
+export declare function sha256Hex(value: string): string;
+export declare function buildMemoryContentHashes(content: string): {
+    contentHash: string;
+    normalizedContentHash: string;
+};
+export declare class MemoryClient {
+    private readonly config;
+    constructor(config?: MemoryConfig);
+    isEnabled(): boolean;
+    isReadEnabled(): boolean;
+    private buildHeaders;
+    private buildEmbeddingHeaders;
+    private requestJson;
+    private ensureCollection;
+    embed(text: string): Promise<number[]>;
+    private findExistingAssetByNormalizedContentHash;
+    upsertAsset(input: {
+        name: string;
+        type: string;
+        description: string;
+        summary: string;
+        content: string;
+        tags?: string[];
+        confidence?: number;
+        sourceProject?: string;
+        sourcePath?: string;
+        usage?: string;
+    }): Promise<MemoryAsset>;
+    search(query: string, limit?: number): Promise<MemorySearchResult[]>;
+    getAsset(assetId: string): Promise<MemoryAsset | null>;
+}
+export declare function createMemoryClient(): MemoryClient;