mcp-probe-kit 3.3.0 → 3.6.0

package/build/schemas/output/memory-tools.js

@@ -0,0 +1,148 @@
+/**
+ * 记忆工具结构化输出 Schema
+ */
+const MemoryAssetHandleSchema = {
+    type: 'object',
+    properties: {
+        id: { type: 'string', description: '记忆资产 ID' },
+        tool: {
+            type: 'string',
+            enum: ['read_memory_asset', 'update_memory_asset', 'delete_memory_asset'],
+            description: '建议调用的 MCP 工具',
+        },
+        name: { type: 'string' },
+        type: { type: 'string' },
+        summary: { type: 'string' },
+    },
+    required: ['id', 'tool'],
+};
+const ToolHandlesSchema = {
+    type: 'object',
+    properties: {
+        memory_assets: {
+            type: 'array',
+            items: MemoryAssetHandleSchema,
+        },
+        graph_snapshot: { type: 'string', description: '图谱快照 URI（probe://graph/...）' },
+        graph_resource: { type: 'string', description: '图谱资源 URI，通常为 probe://graph/latest' },
+    },
+    additionalProperties: false,
+};
+const MemoryAssetSchema = {
+    type: 'object',
+    properties: {
+        id: { type: 'string' },
+        name: { type: 'string' },
+        type: { type: 'string' },
+        description: { type: 'string' },
+        summary: { type: 'string' },
+        content: { type: 'string' },
+        tags: { type: 'array', items: { type: 'string' } },
+        confidence: { type: 'number' },
+        createdAt: { type: 'string' },
+        updatedAt: { type: 'string' },
+    },
+    required: ['id', 'name'],
+};
+export const MemorySearchSchema = {
+    type: 'object',
+    properties: {
+        enabled: { type: 'boolean' },
+        query: { type: 'string' },
+        count: { type: 'number' },
+        results: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    id: { type: 'string' },
+                    score: { type: 'number' },
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    description: { type: 'string' },
+                    summary: { type: 'string' },
+                    content: { type: 'string' },
+                    tags: { type: 'array', items: { type: 'string' } },
+                    sourcePath: { type: 'string' },
+                },
+                required: ['id'],
+            },
+        },
+        handles: ToolHandlesSchema,
+    },
+    required: ['enabled', 'results'],
+};
+export const MemoryAssetDetailSchema = {
+    type: 'object',
+    properties: {
+        enabled: { type: 'boolean' },
+        asset: MemoryAssetSchema,
+        handles: ToolHandlesSchema,
+    },
+    required: ['enabled'],
+};
+export const MemorizeResultSchema = {
+    type: 'object',
+    properties: {
+        enabled: { type: 'boolean' },
+        stored: { type: 'boolean' },
+        asset: MemoryAssetSchema,
+        warnings: { type: 'array', items: { type: 'string' } },
+        handles: ToolHandlesSchema,
+    },
+    required: ['enabled', 'stored'],
+};
+export const DeleteMemoryResultSchema = {
+    type: 'object',
+    properties: {
+        enabled: { type: 'boolean' },
+        deleted: { type: 'boolean' },
+        requires_confirmation: { type: 'boolean', description: '为 true 时表示仅预览，需 confirm=true 再删' },
+        preview: {
+            type: 'object',
+            properties: {
+                id: { type: 'string' },
+                name: { type: 'string' },
+                type: { type: 'string' },
+                summary: { type: 'string' },
+            },
+        },
+        asset: MemoryAssetSchema,
+        handles: ToolHandlesSchema,
+    },
+    required: ['enabled', 'deleted'],
+};
+export const UpdateMemoryResultSchema = {
+    type: 'object',
+    properties: {
+        enabled: { type: 'boolean' },
+        updated: { type: 'boolean' },
+        asset: MemoryAssetSchema,
+        warnings: { type: 'array', items: { type: 'string' } },
+        handles: ToolHandlesSchema,
+    },
+    required: ['enabled', 'updated'],
+};
+export const PatternExtractionSchema = {
+    type: 'object',
+    properties: {
+        summary: { type: 'string' },
+        scannedFiles: { type: 'number' },
+        candidates: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    filePath: { type: 'string' },
+                    summary: { type: 'string' },
+                    tags: { type: 'array', items: { type: 'string' } },
+                },
+                required: ['name', 'filePath'],
+            },
+        },
+        handles: ToolHandlesSchema,
+    },
+    required: ['summary', 'candidates'],
+};

package/build/schemas/project-tools.d.ts

@@ -2,6 +2,25 @@
  * 项目管理工具的 Schema 定义
  */
 export declare const projectToolSchemas: readonly [{
+    readonly name: "workflow";
+    readonly description: "当不确定该用哪个 MCP 工具时使用。根据意图返回分阶段 MCP 指南（firstTool + phases）。同时确保用户项目已存在 .agents/skills/mcp-probe-kit/SKILL.md 与 AGENTS.md 中的 Skill 引用（缺失则自动创建/更新）。";
+    readonly inputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly intent: {
+                readonly type: "string";
+                readonly description: "用户目标或任务描述（自然语言）";
+            };
+            readonly scenario: {
+                readonly type: "string";
+                readonly enum: readonly ["auto", "feature", "bugfix", "ui", "explore", "commit", "review", "refactor", "onboard", "spec", "memory"];
+                readonly description: "可选：显式场景；默认 auto 从 intent 推断";
+            };
+        };
+        readonly required: readonly [];
+        readonly additionalProperties: true;
+    };
+}, {
     readonly name: "init_project_context";
     readonly description: "生成/更新项目上下文：默认写入 AGENTS.md（含 MCP 与 GitNexus 触发规则）及 docs/project-context/。新功能请先 start_feature，修 bug 请先 start_bugfix。完成后 Agent 应阅读 AGENTS.md。";
     readonly inputSchema: {

package/build/schemas/project-tools.js

@@ -2,6 +2,26 @@
  * 项目管理工具的 Schema 定义
  */
 export const projectToolSchemas = [
+    {
+        name: "workflow",
+        description: "当不确定该用哪个 MCP 工具时使用。根据意图返回分阶段 MCP 指南（firstTool + phases）。同时确保用户项目已存在 .agents/skills/mcp-probe-kit/SKILL.md 与 AGENTS.md 中的 Skill 引用（缺失则自动创建/更新）。",
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: {
+                    type: "string",
+                    description: "用户目标或任务描述（自然语言）",
+                },
+                scenario: {
+                    type: "string",
+                    enum: ["auto", "feature", "bugfix", "ui", "explore", "commit", "review", "refactor", "onboard", "spec", "memory"],
+                    description: "可选：显式场景；默认 auto 从 intent 推断",
+                },
+            },
+            required: [],
+            additionalProperties: true,
+        },
+    },
     {
         name: "init_project_context",
         description: "生成/更新项目上下文：默认写入 AGENTS.md（含 MCP 与 GitNexus 触发规则）及 docs/project-context/。新功能请先 start_feature，修 bug 请先 start_bugfix。完成后 Agent 应阅读 AGENTS.md。",

package/build/tools/__tests__/delete_memory_asset.unit.test.d.ts

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

package/build/tools/__tests__/delete_memory_asset.unit.test.js

@@ -0,0 +1,87 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+const deleteAssetMock = vi.fn();
+const getAssetMock = vi.fn();
+const isReadEnabledMock = vi.fn();
+vi.mock('../../lib/memory-client.js', () => ({
+    createMemoryClient: () => ({
+        isReadEnabled: isReadEnabledMock,
+        getAsset: getAssetMock,
+        deleteAsset: deleteAssetMock,
+    }),
+}));
+import { deleteMemoryAsset } from '../delete_memory_asset.js';
+const sampleAsset = {
+    id: 'asset-1',
+    name: 'obsolete-pattern',
+    type: 'pattern',
+    description: 'Outdated pattern',
+    summary: 'no longer used',
+    content: 'old code',
+    tags: ['pattern'],
+    confidence: 0.8,
+    createdAt: '2026-01-01T00:00:00.000Z',
+    updatedAt: '2026-01-01T00:00:00.000Z',
+};
+beforeEach(() => {
+    isReadEnabledMock.mockReset();
+    deleteAssetMock.mockReset();
+    getAssetMock.mockReset();
+});
+afterEach(() => {
+    vi.clearAllMocks();
+});
+describe('delete_memory_asset 单元测试', () => {
+    test('记忆服务未开启时返回跳过结果', async () => {
+        isReadEnabledMock.mockReturnValue(false);
+        const result = await deleteMemoryAsset({ asset_id: 'asset-1' });
+        expect(result.isError).toBe(false);
+        expect(result.content[0].text).toContain('记忆服务未开启');
+        expect(deleteAssetMock).not.toHaveBeenCalled();
+        expect(getAssetMock).not.toHaveBeenCalled();
+    });
+    test('未 confirm 时返回预览并要求确认', async () => {
+        isReadEnabledMock.mockReturnValue(true);
+        getAssetMock.mockResolvedValue(sampleAsset);
+        const result = await deleteMemoryAsset({ asset_id: 'asset-1' });
+        expect(result.isError).toBe(false);
+        if (!('structuredContent' in result) || !result.structuredContent) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('待确认删除');
+        expect(result.structuredContent?.requires_confirmation).toBe(true);
+        expect(result.structuredContent?.preview?.name).toBe('obsolete-pattern');
+        expect(result.structuredContent?.handles?.memory_assets?.[0]?.tool).toBe('delete_memory_asset');
+        expect(deleteAssetMock).not.toHaveBeenCalled();
+    });
+    test('资产不存在时返回未找到', async () => {
+        isReadEnabledMock.mockReturnValue(true);
+        getAssetMock.mockResolvedValue(null);
+        const result = await deleteMemoryAsset({ asset_id: 'missing-id' });
+        expect(result.isError).toBe(false);
+        if (!('structuredContent' in result) || !result.structuredContent) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('未找到记忆资产');
+        expect(result.structuredContent.deleted).toBe(false);
+        expect(deleteAssetMock).not.toHaveBeenCalled();
+    });
+    test('confirm=true 删除成功时返回资产信息', async () => {
+        isReadEnabledMock.mockReturnValue(true);
+        deleteAssetMock.mockResolvedValue({ deleted: true, asset: sampleAsset });
+        const result = await deleteMemoryAsset({ asset_id: 'asset-1', confirm: true });
+        expect(result.isError).toBe(false);
+        if (!('structuredContent' in result) || !result.structuredContent) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('已删除记忆资产: obsolete-pattern');
+        expect(result.structuredContent.deleted).toBe(true);
+        expect(result.structuredContent.requires_confirmation).toBe(false);
+        expect(result.structuredContent.asset.name).toBe('obsolete-pattern');
+        expect(getAssetMock).not.toHaveBeenCalled();
+    });
+    test('缺少 asset_id 时返回错误', async () => {
+        const result = await deleteMemoryAsset({});
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('asset_id');
+    });
+});

package/build/tools/__tests__/search_memory.unit.test.js

@@ -85,5 +85,6 @@ describe('search_memory 单元测试', () => {
             description: 'Feishu proxy mismatch',
             summary: 'proxy caused 400 on HTTPS',
         }));
+        expect(result.structuredContent.handles.memory_assets[0]).toEqual(expect.objectContaining({ id: 'asset-1', tool: 'read_memory_asset' }));
     });
 });

package/build/tools/__tests__/start_bugfix.unit.test.js

@@ -1,8 +1,20 @@
 /**
  * 单元测试：start_bugfix 工具（委托式编排）
  */
-import { describe, test, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { afterEach, describe, test, expect } from 'vitest';
 import { startBugfix } from '../start_bugfix.js';
+const tempDirs = [];
+afterEach(() => {
+    while (tempDirs.length > 0) {
+        const dir = tempDirs.pop();
+        if (dir) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    }
+});
 describe('start_bugfix 单元测试', () => {
     test('缺少必填参数时返回错误', async () => {
         const result = await startBugfix({});
@@ -38,6 +50,27 @@ describe('start_bugfix 单元测试', () => {
         expect(structured?.metadata?.graphDocs?.latestMarkdownPath).toBe('docs/graph-insights/latest.md');
         expect(structured?.metadata?.graphContext?.summary).toMatch(/GitNexus|图谱|降级/);
     });
+    test('关联规格存在时计划包含 check_spec 闸门', async () => {
+        const root = fs.mkdtempSync(path.join(os.tmpdir(), 'bugfix-spec-'));
+        tempDirs.push(root);
+        const featureName = 'checkout-flow';
+        const specDir = path.join(root, 'docs', 'specs', featureName);
+        fs.mkdirSync(specDir, { recursive: true });
+        fs.writeFileSync(path.join(specDir, 'requirements.md'), '# requirements\n');
+        const result = await startBugfix({
+            error_message: 'checkout total wrong',
+            feature_name: featureName,
+            docs_dir: 'docs',
+            project_root: root,
+        });
+        expect(result.isError).toBe(false);
+        const structured = result.structuredContent;
+        const checkStep = structured?.metadata?.plan?.steps?.find((step) => step.tool === 'check_spec');
+        expect(checkStep).toBeTruthy();
+        expect(checkStep.args.feature_name).toBe(featureName);
+        expect(structured.metadata.specGate.featureName).toBe(featureName);
+        expect(result.content[0].text).toMatch(/check_spec|规格闸门/);
+    });
     test('loop 模式返回需求循环结构', async () => {
         const result = await startBugfix({
             error_message: 'NullReference',

package/build/tools/__tests__/update_memory_asset.unit.test.d.ts

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

package/build/tools/__tests__/update_memory_asset.unit.test.js

@@ -0,0 +1,82 @@
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
+const updateAssetMock = vi.fn();
+const isEnabledMock = vi.fn();
+vi.mock('../../lib/memory-client.js', () => ({
+    createMemoryClient: () => ({
+        isEnabled: isEnabledMock,
+        updateAsset: updateAssetMock,
+    }),
+}));
+import { updateMemoryAsset } from '../update_memory_asset.js';
+beforeEach(() => {
+    isEnabledMock.mockReset();
+    updateAssetMock.mockReset();
+});
+afterEach(() => {
+    vi.clearAllMocks();
+});
+describe('update_memory_asset 单元测试', () => {
+    test('记忆服务未开启时返回跳过结果', async () => {
+        isEnabledMock.mockReturnValue(false);
+        const result = await updateMemoryAsset({ asset_id: 'asset-1', summary: 'new summary' });
+        expect(result.isError).toBe(false);
+        expect('structuredContent' in result).toBe(true);
+        if (!('structuredContent' in result)) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('记忆服务未开启');
+        expect(updateAssetMock).not.toHaveBeenCalled();
+    });
+    test('资产不存在时返回未找到', async () => {
+        isEnabledMock.mockReturnValue(true);
+        updateAssetMock.mockResolvedValue({ updated: false, asset: null });
+        const result = await updateMemoryAsset({ asset_id: 'missing-id', summary: 'new summary' });
+        expect(result.isError).toBe(false);
+        expect('structuredContent' in result).toBe(true);
+        if (!('structuredContent' in result)) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('未找到记忆资产');
+        expect(result.structuredContent.updated).toBe(false);
+    });
+    test('更新成功时返回资产信息', async () => {
+        isEnabledMock.mockReturnValue(true);
+        updateAssetMock.mockResolvedValue({
+            updated: true,
+            asset: {
+                id: 'asset-1',
+                name: 'feishu-proxy-bug',
+                type: 'bugfix',
+                description: 'Feishu proxy mismatch',
+                summary: 'updated summary',
+                content: '【现象】submit 成功\n【根因】HTTP_PROXY 污染\n【修复】proxy:false',
+                tags: ['bugfix'],
+                confidence: 0.9,
+                createdAt: '2026-01-01T00:00:00.000Z',
+                updatedAt: '2026-01-02T00:00:00.000Z',
+            },
+        });
+        const result = await updateMemoryAsset({
+            asset_id: 'asset-1',
+            summary: 'updated summary',
+        });
+        expect(result.isError).toBe(false);
+        expect('structuredContent' in result).toBe(true);
+        if (!('structuredContent' in result)) {
+            throw new Error('structuredContent 缺失');
+        }
+        expect(result.content[0].text).toContain('已更新记忆资产: feishu-proxy-bug');
+        expect(result.structuredContent.updated).toBe(true);
+        expect(updateAssetMock).toHaveBeenCalledWith('asset-1', { summary: 'updated summary' });
+    });
+    test('缺少 asset_id 时返回错误', async () => {
+        const result = await updateMemoryAsset({ summary: 'only summary' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('asset_id');
+    });
+    test('未提供任何更新字段时返回错误', async () => {
+        const result = await updateMemoryAsset({ asset_id: 'asset-1' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain('至少提供一个待更新字段');
+    });
+});

package/build/tools/__tests__/workflow.unit.test.d.ts

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

package/build/tools/__tests__/workflow.unit.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'vitest';
+import { workflow } from '../workflow.js';
+describe('workflow 工具', () => {
+    test('新功能意图返回 start_feature 为首工具', async () => {
+        const result = await workflow({ intent: '实现订单导出功能' });
+        expect(result.isError).toBe(false);
+        expect('structuredContent' in result).toBe(true);
+        if (!('structuredContent' in result) || !result.structuredContent) {
+            throw new Error('missing structuredContent');
+        }
+        expect(result.structuredContent.firstTool).toBe('start_feature');
+        expect(result.structuredContent.scenario).toBe('feature');
+        expect(result.content[0].text).toContain('start_feature');
+        expect(result.structuredContent.handles?.next_tool).toBe('start_feature');
+    });
+    test('Bug 意图返回 start_bugfix', async () => {
+        const result = await workflow({ intent: '修复支付接口 500 错误', scenario: 'bugfix' });
+        expect(result.isError).toBe(false);
+        if (!('structuredContent' in result) || !result.structuredContent) {
+            throw new Error('missing structuredContent');
+        }
+        expect(result.structuredContent.firstTool).toBe('start_bugfix');
+    });
+});

package/build/tools/code_insight.js

@@ -4,6 +4,7 @@ import { parseArgs, getString, getNumber, getBoolean } from "../utils/parseArgs.
 import { okStructured } from "../lib/response.js";
 import { renderOrchestrationHeader } from "../lib/orchestration-guidance.js";
 import { runCodeInsightBridge, } from "../lib/gitnexus-bridge.js";
+import { attachHandles, DEFAULT_GRAPH_RESOURCE_URI } from "../lib/handles.js";
 import { throwIfAborted, } from "../lib/tool-execution-context.js";
 import { isLikelyProjectNamedRelativePath, buildProjectRootRetryHint, resolveWorkspaceRoot } from "../lib/workspace-root.js";
 import { layoutAbsPath, parseLayoutArgsFromRecord, resolveProjectContextLayout, } from "../lib/project-context-layout.js";
@@ -370,6 +371,9 @@ ${result.warnings.length > 0 ? `警告: ${result.warnings.join(", ")}` : ""}`.tr
             : projectDocs
                 ? `请按 delegated plan 落盘图谱文档，并更新 ${projectDocs.projectContextFilePath} 的索引入口`
                 : null;
+        const structuredWithHandles = attachHandles(structured, {
+            graph_resource: DEFAULT_GRAPH_RESOURCE_URI,
+        });
         return okStructured(delegatedPlan
             ? `${renderOrchestrationHeader({
                 tool: "code_insight",
@@ -405,7 +409,7 @@ ${delegatedPlan.kind === "docs" && projectDocs ? `后续操作:
 ${usageGuide}`
             : `${message}
 
-${usageGuide}`, structured);
+${usageGuide}`, structuredWithHandles);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/build/tools/delete_memory_asset.d.ts

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

package/build/tools/delete_memory_asset.js

@@ -0,0 +1,57 @@
+import { okStructured } from '../lib/response.js';
+import { createMemoryClient } from '../lib/memory-client.js';
+import { handleToolError } from '../utils/error-handler.js';
+import { attachHandles, buildMemoryAssetHandles } from '../lib/handles.js';
+function isConfirmTrue(value) {
+    return value === true || value === 'true' || value === 1 || value === '1';
+}
+export async function deleteMemoryAsset(args) {
+    try {
+        const assetId = typeof args?.asset_id === 'string' ? args.asset_id.trim() : '';
+        if (!assetId) {
+            throw new Error('缺少必填参数: asset_id');
+        }
+        const confirm = isConfirmTrue(args?.confirm);
+        const client = createMemoryClient();
+        if (!client.isReadEnabled()) {
+            return okStructured('记忆服务未开启，已跳过删除。', { enabled: false, deleted: false, asset: null });
+        }
+        if (!confirm) {
+            const existing = await client.getAsset(assetId);
+            if (!existing) {
+                return okStructured(`未找到记忆资产: ${assetId}`, attachHandles({ enabled: true, deleted: false, requires_confirmation: false, asset: null }, { memory_assets: buildMemoryAssetHandles([{ id: assetId }], 'delete_memory_asset') }));
+            }
+            return okStructured(`待确认删除记忆资产: ${existing.name}。请先用 read_memory_asset 核对内容，确认后带 confirm: true 重新调用 delete_memory_asset。`, attachHandles({
+                enabled: true,
+                deleted: false,
+                requires_confirmation: true,
+                preview: {
+                    id: existing.id,
+                    name: existing.name,
+                    type: existing.type,
+                    summary: existing.summary,
+                },
+                asset: null,
+            }, {
+                memory_assets: buildMemoryAssetHandles([{ id: existing.id, name: existing.name, type: existing.type, summary: existing.summary }], 'delete_memory_asset'),
+            }));
+        }
+        const { deleted, asset } = await client.deleteAsset(assetId);
+        if (!deleted) {
+            return okStructured(`未找到记忆资产: ${assetId}`, attachHandles({ enabled: true, deleted: false, requires_confirmation: false, asset: null }, { memory_assets: buildMemoryAssetHandles([{ id: assetId }], 'delete_memory_asset') }));
+        }
+        return okStructured(`已删除记忆资产: ${asset?.name ?? assetId}`, attachHandles({
+            enabled: true,
+            deleted: true,
+            requires_confirmation: false,
+            asset,
+        }, asset
+            ? {
+                memory_assets: buildMemoryAssetHandles([{ id: asset.id, name: asset.name, type: asset.type, summary: asset.summary }], 'delete_memory_asset'),
+            }
+            : {}));
+    }
+    catch (error) {
+        return handleToolError(error, 'delete_memory_asset');
+    }
+}

package/build/tools/index.d.ts

@@ -5,6 +5,7 @@ export { codeInsight } from "./code_insight.js";
 export { gentest } from "./gentest.js";
 export { refactor } from "./refactor.js";
 export { initProjectContext } from "./init_project_context.js";
+export { workflow } from "./workflow.js";
 export { addFeature } from "./add_feature.js";
 export { checkSpec } from "./check_spec.js";
 export { fixBug } from "./fix_bug.js";
@@ -20,6 +21,8 @@ export { startUi } from "./start_ui.js";
 export { searchMemory } from "./search_memory.js";
 export { readMemoryAsset } from "./read_memory_asset.js";
 export { memorizeAsset } from "./memorize_asset.js";
+export { deleteMemoryAsset } from "./delete_memory_asset.js";
+export { updateMemoryAsset } from "./update_memory_asset.js";
 export { scanAndExtractPatterns } from "./scan_and_extract_patterns.js";
 export { startProduct } from "./start_product.js";
 export { gitWorkReport } from "./git_work_report.js";

package/build/tools/index.js

@@ -5,6 +5,7 @@ export { codeInsight } from "./code_insight.js";
 export { gentest } from "./gentest.js";
 export { refactor } from "./refactor.js";
 export { initProjectContext } from "./init_project_context.js";
+export { workflow } from "./workflow.js";
 export { addFeature } from "./add_feature.js";
 export { checkSpec } from "./check_spec.js";
 export { fixBug } from "./fix_bug.js";
@@ -24,6 +25,8 @@ export { startUi } from "./start_ui.js";
 export { searchMemory } from "./search_memory.js";
 export { readMemoryAsset } from "./read_memory_asset.js";
 export { memorizeAsset } from "./memorize_asset.js";
+export { deleteMemoryAsset } from "./delete_memory_asset.js";
+export { updateMemoryAsset } from "./update_memory_asset.js";
 export { scanAndExtractPatterns } from "./scan_and_extract_patterns.js";
 // 产品设计工作流
 export { startProduct } from "./start_product.js";

package/build/tools/search_memory.js

@@ -2,6 +2,7 @@ import { parseArgs, getString, getNumber } from '../utils/parseArgs.js';
 import { okStructured } from '../lib/response.js';
 import { createMemoryClient } from '../lib/memory-client.js';
 import { formatSearchMemoryResultsText, shouldShowSourceInSearch, } from '../lib/memory-orchestration.js';
+import { attachHandles, buildMemoryAssetHandles } from '../lib/handles.js';
 import { getMemoryConfig } from '../lib/memory-config.js';
 import { handleToolError } from '../utils/error-handler.js';
 export async function searchMemory(args) {
@@ -46,12 +47,14 @@ export async function searchMemory(args) {
             tags: item.tags,
             sourcePath: shouldShowSourceInSearch(item, config) ? item.sourcePath : undefined,
         }));
-        return okStructured(formatSearchMemoryResultsText(results, config), {
+        return okStructured(formatSearchMemoryResultsText(results, config), attachHandles({
             enabled: true,
             query,
             count: results.length,
             results: items,
-        });
+        }, {
+            memory_assets: buildMemoryAssetHandles(items),
+        }));
     }
     catch (error) {
         return handleToolError(error, 'search_memory');