@mclawnet/mcp-server 0.1.0

package/src/__tests__/evolution-tools.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { EvolutionPipeline } from "@mclawnet/skill-manager";
+import {
+  getEvolutionToolDefinitions,
+  handleEvolutionToolCall,
+} from "../tools/evolution.js";
+
+describe("Evolution MCP Tools", () => {
+  let tempDir: string;
+  let pipeline: EvolutionPipeline;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "evo-mcp-"));
+    pipeline = new EvolutionPipeline(tempDir);
+    // seed a skill
+    const skillDir = join(tempDir, ".claude", "skills", "demo");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---\nname: demo\ndescription: demo skill\n---\n# demo`,
+    );
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should define expected tools", () => {
+    const defs = getEvolutionToolDefinitions();
+    const names = defs.map((d) => d.name);
+    expect(names).toEqual([
+      "skill_evolve",
+      "skill_pending_list",
+      "skill_pending_approve",
+      "skill_pending_reject",
+    ]);
+  });
+
+  it("skill_evolve should process a proposal and auto-approve small change", async () => {
+    const result = await handleEvolutionToolCall(
+      "skill_evolve",
+      {
+        skillName: "demo",
+        signal: "skill-error-fixed",
+        problem: "missing note",
+        fix: "added note",
+        patch: `---\nname: demo\ndescription: demo skill\n---\n# demo\nnew`,
+      },
+      { pipeline },
+    );
+    const parsed = JSON.parse(result.content[0].text);
+    expect(["auto-approve", "needs-review"]).toContain(parsed.action);
+  });
+
+  it("skill_pending_list should return empty initially", async () => {
+    const result = await handleEvolutionToolCall(
+      "skill_pending_list",
+      {},
+      { pipeline },
+    );
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.pending).toHaveLength(0);
+  });
+
+  it("skill_pending_approve should fail for unknown id", async () => {
+    const result = await handleEvolutionToolCall(
+      "skill_pending_approve",
+      { id: "nope" },
+      { pipeline },
+    );
+    expect(result.isError).toBe(true);
+  });
+
+  it("skill_pending_reject should fail for unknown id", async () => {
+    const result = await handleEvolutionToolCall(
+      "skill_pending_reject",
+      { id: "nope" },
+      { pipeline },
+    );
+    expect(result.isError).toBe(true);
+  });
+
+  it("invalid proposal should return error", async () => {
+    const result = await handleEvolutionToolCall(
+      "skill_evolve",
+      { skillName: "", signal: "skill-error-fixed", problem: "", fix: "", patch: "" },
+      { pipeline },
+    );
+    expect(result.isError).toBe(true);
+  });
+});

package/src/__tests__/memory-tools.test.ts

@@ -0,0 +1,259 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { EmbeddingService, initDatabase, MemoryStore } from "@mclawnet/memory";
+import {
+  getMemoryToolDefinitions as getToolDefinitions,
+  handleMemoryToolCall as handleToolCall,
+  type MemoryToolContext as ToolContext,
+} from "../tools/memory.js";
+import type { Database as DatabaseType } from "better-sqlite3";
+
+let db: DatabaseType;
+let store: MemoryStore;
+let embeddingService: EmbeddingService;
+let context: ToolContext;
+
+beforeEach(() => {
+  db = initDatabase(":memory:");
+  store = new MemoryStore(db);
+  embeddingService = new EmbeddingService(db);
+  context = { store, embeddingService };
+});
+
+// ── Tool definitions ───────────────────────────────────────────────
+
+describe("getToolDefinitions", () => {
+  it("should return 4 tool definitions", () => {
+    const tools = getToolDefinitions();
+    expect(tools).toHaveLength(4);
+  });
+
+  it("should have the correct tool names", () => {
+    const tools = getToolDefinitions();
+    const names = tools.map((t) => t.name);
+    expect(names).toEqual([
+      "memory_search",
+      "memory_store",
+      "memory_stats",
+      "memory_reflect",
+    ]);
+  });
+
+  it("should have inputSchema on each tool", () => {
+    const tools = getToolDefinitions();
+    for (const tool of tools) {
+      expect(tool.inputSchema).toBeDefined();
+      expect(tool.inputSchema.type).toBe("object");
+    }
+  });
+});
+
+// ── memory_search ──────────────────────────────────────────────────
+
+describe("memory_search handler", () => {
+  it("should find a stored memory by semantic search", async () => {
+    // Store a memory with embedding first
+    await store.addMemoryWithEmbedding(
+      {
+        roleId: "role-developer",
+        content: "React hooks require careful dependency arrays",
+        type: "pattern",
+        domain: "frontend",
+      },
+      embeddingService,
+    );
+
+    const result = await handleToolCall(
+      "memory_search",
+      { roleId: "role-developer", query: "React hooks require careful dependency arrays" },
+      context,
+    );
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+    expect(result.isError).toBeUndefined();
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed).toBeInstanceOf(Array);
+    expect(parsed.length).toBeGreaterThan(0);
+    expect(parsed[0].content).toBe("React hooks require careful dependency arrays");
+  });
+
+  it("should return empty array when no memories exist", async () => {
+    const result = await handleToolCall(
+      "memory_search",
+      { roleId: "role-developer", query: "nonexistent topic" },
+      context,
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed).toEqual([]);
+  });
+
+  it("should respect crossRole flag", async () => {
+    await store.addMemoryWithEmbedding(
+      { roleId: "role-reviewer", content: "cross role memory", type: "experience" },
+      embeddingService,
+    );
+
+    // Without crossRole, searching as developer should not find reviewer memory
+    const result1 = await handleToolCall(
+      "memory_search",
+      { roleId: "role-developer", query: "cross role memory", crossRole: false },
+      context,
+    );
+    const parsed1 = JSON.parse(result1.content[0].text);
+    expect(parsed1).toHaveLength(0);
+
+    // With crossRole, should find it
+    const result2 = await handleToolCall(
+      "memory_search",
+      { roleId: "role-developer", query: "cross role memory", crossRole: true },
+      context,
+    );
+    const parsed2 = JSON.parse(result2.content[0].text);
+    expect(parsed2.length).toBeGreaterThan(0);
+    expect(parsed2[0].content).toBe("cross role memory");
+  });
+});
+
+// ── memory_store ───────────────────────────────────────────────────
+
+describe("memory_store handler", () => {
+  it("should store a memory and return success with id", async () => {
+    const result = await handleToolCall(
+      "memory_store",
+      {
+        roleId: "role-developer",
+        content: "Always run tests before committing",
+        type: "pattern",
+        tags: ["workflow", "testing"],
+        domain: "ci",
+        importance: 0.8,
+      },
+      context,
+    );
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.success).toBe(true);
+    expect(parsed.id).toBeDefined();
+    expect(typeof parsed.id).toBe("string");
+
+    // Verify stored in DB
+    const mem = store.getMemory(parsed.id);
+    expect(mem).not.toBeNull();
+    expect(mem!.content).toBe("Always run tests before committing");
+    expect(mem!.type).toBe("pattern");
+    expect(mem!.tags).toEqual(["workflow", "testing"]);
+    expect(mem!.domain).toBe("ci");
+    expect(mem!.importance).toBe(0.8);
+    expect(mem!.roleId).toBe("role-developer");
+    expect(mem!.level).toBe("long-term");
+  });
+
+  it("should store memory with minimal args", async () => {
+    const result = await handleToolCall(
+      "memory_store",
+      { roleId: "role-developer", content: "Something learned", type: "experience" },
+      context,
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.success).toBe(true);
+
+    const mem = store.getMemory(parsed.id);
+    expect(mem!.tags).toEqual([]);
+    expect(mem!.domain).toBeUndefined();
+    expect(mem!.importance).toBe(0.5); // default
+  });
+
+  it("should have an embedding after store", async () => {
+    const result = await handleToolCall(
+      "memory_store",
+      { roleId: "role-developer", content: "Memory with embedding", type: "pattern" },
+      context,
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    const mem = store.getMemory(parsed.id);
+    expect(mem!.embedding).toBeInstanceOf(Float32Array);
+    expect(mem!.embedding!.length).toBe(128);
+  });
+});
+
+// ── memory_stats ───────────────────────────────────────────────────
+
+describe("memory_stats handler", () => {
+  it("should return stats for current role", async () => {
+    // Add some memories
+    store.addMemory({ roleId: "role-developer", content: "exp1", type: "experience" });
+    store.addMemory({ roleId: "role-developer", content: "pat1", type: "pattern", domain: "frontend" });
+    store.addMemory({ roleId: "role-developer", content: "err1", type: "error", domain: "frontend" });
+
+    const result = await handleToolCall("memory_stats", { roleId: "role-developer" }, context);
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+
+    const stats = JSON.parse(result.content[0].text);
+    expect(stats.totalMemories).toBe(3);
+    expect(stats.byType.experience).toBe(1);
+    expect(stats.byType.pattern).toBe(1);
+    expect(stats.byType.error).toBe(1);
+    expect(stats.topDomains).toContainEqual({ domain: "frontend", count: 2 });
+  });
+
+  it("should return zero stats for role with no memories", async () => {
+    const result = await handleToolCall("memory_stats", { roleId: "role-developer" }, context);
+    const stats = JSON.parse(result.content[0].text);
+    expect(stats.totalMemories).toBe(0);
+  });
+});
+
+// ── memory_reflect ─────────────────────────────────────────────────
+
+describe("memory_reflect handler", () => {
+  it("should perform light pruning and return results", async () => {
+    const result = await handleToolCall(
+      "memory_reflect",
+      { roleId: "role-developer", scope: "light" },
+      context,
+    );
+
+    expect(result.content).toHaveLength(1);
+    expect(result.content[0].type).toBe("text");
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.scope).toBe("light");
+    expect(typeof parsed.recalculated).toBe("number");
+    expect(typeof parsed.demotedToLongTerm).toBe("number");
+  });
+
+  it("should perform full reflect across all roles", async () => {
+    const result = await handleToolCall(
+      "memory_reflect",
+      { roleId: "role-developer", scope: "full" },
+      context,
+    );
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.scope).toBe("full");
+    expect(typeof parsed.recalculated).toBe("number");
+    expect(typeof parsed.rolesProcessed).toBe("number");
+    expect(typeof parsed.profilesRefreshed).toBe("number");
+  });
+});
+
+// ── Unknown tool ───────────────────────────────────────────────────
+
+describe("unknown tool", () => {
+  it("should return isError for unknown tool name", async () => {
+    const result = await handleToolCall("nonexistent_tool", {}, context);
+    expect(result.isError).toBe(true);
+
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.error).toContain("Unknown tool");
+  });
+});

package/src/__tests__/skill-tools.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { SkillStore } from "@mclawnet/skill-manager";
+import { getSkillToolDefinitions, handleSkillToolCall } from "../tools/skill.js";
+
+describe("Skill MCP Tools", () => {
+  let tempDir: string;
+  let store: SkillStore;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "skill-mcp-test-"));
+    store = new SkillStore(tempDir);
+    const skillDir = join(tempDir, ".claude", "skills", "test-skill");
+    mkdirSync(skillDir, { recursive: true });
+    writeFileSync(
+      join(skillDir, "SKILL.md"),
+      `---
+name: test-skill
+description: A test skill for testing
+---
+# Test`,
+    );
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("should define skill_list and skill_read tools", () => {
+    const defs = getSkillToolDefinitions();
+    const names = defs.map((d) => d.name);
+    expect(names).toContain("skill_list");
+    expect(names).toContain("skill_read");
+  });
+
+  it("skill_list should return installed skills", async () => {
+    const result = await handleSkillToolCall("skill_list", {}, { store });
+    expect(result.isError).toBeUndefined();
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.skills).toHaveLength(1);
+    expect(parsed.skills[0].name).toBe("test-skill");
+    expect(parsed.total).toBe(1);
+  });
+
+  it("skill_read should return SKILL.md content", async () => {
+    const result = await handleSkillToolCall(
+      "skill_read",
+      { name: "test-skill" },
+      { store },
+    );
+    expect(result.isError).toBeUndefined();
+    expect(result.content[0].text).toContain("# Test");
+    expect(result.content[0].text).toContain("name: test-skill");
+  });
+
+  it("skill_read should return error for unknown skill", async () => {
+    const result = await handleSkillToolCall(
+      "skill_read",
+      { name: "nonexistent" },
+      { store },
+    );
+    expect(result.isError).toBe(true);
+    const parsed = JSON.parse(result.content[0].text);
+    expect(parsed.error).toContain("not found");
+  });
+
+  it("should return error for missing name arg", async () => {
+    const result = await handleSkillToolCall("skill_read", {}, { store });
+    expect(result.isError).toBe(true);
+  });
+
+  it("should return error for unknown tool", async () => {
+    const result = await handleSkillToolCall("skill_unknown", {}, { store });
+    expect(result.isError).toBe(true);
+  });
+});

package/src/index.ts

@@ -0,0 +1,3 @@
+// @mclawnet/mcp-server — 统一 MCP 传输层
+export { getAllToolDefinitions, routeToolCall } from "./tools/index.js";
+export type { MemoryToolContext, ToolContext } from "./tools/index.js";

package/src/server.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { createLogger } from "@mclawnet/logger";
+import {
+  createEmbeddingProviders,
+  EmbeddingService,
+  initDatabase,
+  MemoryStore,
+} from "@mclawnet/memory";
+import { SkillStore, EvolutionPipeline } from "@mclawnet/skill-manager";
+import { getAllToolDefinitions, routeToolCall, type ToolContext } from "./tools/index.js";
+
+const log = createLogger({ module: "mcp-server" });
+
+const dbPath = process.env.CLAWNET_MEMORY_DB ?? join(homedir(), ".clawnet", "memory.db");
+const db = initDatabase(dbPath);
+
+log.info({ dbPath }, "ClawNet MCP server starting");
+
+const store = new MemoryStore(db);
+const providers = createEmbeddingProviders();
+const embeddingService = new EmbeddingService(db, providers);
+
+const clawnetDir = process.env.CLAWNET_DIR ?? join(homedir(), ".clawnet");
+const skillStore = new SkillStore(clawnetDir);
+const evolutionPipeline = new EvolutionPipeline(clawnetDir);
+
+const context: ToolContext = {
+  memory: { store, embeddingService },
+  skill: { store: skillStore },
+  evolution: { pipeline: evolutionPipeline },
+};
+
+const server = new Server(
+  { name: "clawnet-mcp", version: "0.1.0" },
+  { capabilities: { tools: {} } },
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: getAllToolDefinitions(),
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  return routeToolCall(name, (args ?? {}) as Record<string, unknown>, context);
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+
+log.info("ClawNet MCP server connected via stdio");
+
+function cleanup() {
+  log.info("ClawNet MCP server shutting down");
+  try {
+    db.close();
+  } catch {
+    // ignore
+  }
+}
+
+process.on("exit", cleanup);
+process.on("SIGINT", () => {
+  cleanup();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  cleanup();
+  process.exit(0);
+});

package/src/tools/evolution.ts

@@ -0,0 +1,157 @@
+import { createLogger } from "@mclawnet/logger";
+import type { EvolutionPipeline } from "@mclawnet/skill-manager";
+
+const logger = createLogger({ module: "mcp-server/tools/evolution" });
+
+export interface EvolutionToolContext {
+  pipeline: EvolutionPipeline;
+}
+
+// Layer 1 实时进化默认置信度
+const LAYER1_DEFAULT_CONFIDENCE = 0.85;
+
+export function getEvolutionToolDefinitions() {
+  return [
+    {
+      name: "skill_evolve",
+      description: `提交 Skill 进化提案。仅在以下强信号出现时调用：
+1. 你按照某个 skill 执行但遇到错误，修正后才成功 (signal: skill-error-fixed)
+2. 用户指出某个 skill 的指引有误，并给出了正确做法 (signal: user-correction)
+3. 你发现某个 skill 缺少关键步骤，实践中你补上了 (signal: missing-step)
+4. 某个 skill 的指引在当前平台/环境不适用 (signal: platform-mismatch)
+
+不要在以下情况调用：
+- skill 正常工作没有问题
+- 只是"可能更好"的优化建议
+- 用户没有使用任何 skill 的普通对话`,
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          skillName: { type: "string", description: "要进化的 skill 名称" },
+          signal: {
+            type: "string",
+            enum: [
+              "skill-error-fixed",
+              "user-correction",
+              "missing-step",
+              "platform-mismatch",
+            ],
+          },
+          problem: { type: "string", description: "遇到了什么问题" },
+          fix: { type: "string", description: "怎么修正的" },
+          patch: {
+            type: "string",
+            description: "修改后的完整 SKILL.md 内容",
+          },
+        },
+        required: ["skillName", "signal", "problem", "fix", "patch"],
+      },
+    },
+    {
+      name: "skill_pending_list",
+      description: "列出所有待审核的 Skill 进化提案。",
+      inputSchema: { type: "object" as const, properties: {} },
+    },
+    {
+      name: "skill_pending_approve",
+      description: "批准一条待审核的 Skill 进化提案并应用到本地 skill。",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          id: { type: "string", description: "pending 提案 id" },
+        },
+        required: ["id"],
+      },
+    },
+    {
+      name: "skill_pending_reject",
+      description: "拒绝一条待审核的 Skill 进化提案（不应用，从队列移除）。",
+      inputSchema: {
+        type: "object" as const,
+        properties: {
+          id: { type: "string", description: "pending 提案 id" },
+        },
+        required: ["id"],
+      },
+    },
+  ];
+}
+
+export async function handleEvolutionToolCall(
+  name: string,
+  args: Record<string, unknown>,
+  context: EvolutionToolContext,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  try {
+    switch (name) {
+      case "skill_evolve": {
+        const result = await context.pipeline.process({
+          skillName: String(args.skillName ?? ""),
+          signal: args.signal as
+            | "skill-error-fixed"
+            | "user-correction"
+            | "missing-step"
+            | "platform-mismatch",
+          problem: String(args.problem ?? ""),
+          fix: String(args.fix ?? ""),
+          patch: String(args.patch ?? ""),
+          confidence: LAYER1_DEFAULT_CONFIDENCE,
+          source: "layer1-realtime",
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          isError: result.action === "rejected" || result.action === "blocked",
+        };
+      }
+      case "skill_pending_list": {
+        const pending = context.pipeline.listPending();
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ pending, total: pending.length }) },
+          ],
+        };
+      }
+      case "skill_pending_approve": {
+        const id = String(args.id ?? "");
+        if (!id) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "id is required" }) }],
+            isError: true,
+          };
+        }
+        const result = context.pipeline.approvePending(id);
+        return {
+          content: [{ type: "text", text: JSON.stringify(result) }],
+          isError: !result.applied,
+        };
+      }
+      case "skill_pending_reject": {
+        const id = String(args.id ?? "");
+        if (!id) {
+          return {
+            content: [{ type: "text", text: JSON.stringify({ error: "id is required" }) }],
+            isError: true,
+          };
+        }
+        const removed = context.pipeline.rejectPending(id);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ removed }) }],
+          isError: !removed,
+        };
+      }
+      default:
+        return {
+          content: [
+            { type: "text", text: JSON.stringify({ error: `Unknown evolution tool: ${name}` }) },
+          ],
+          isError: true,
+        };
+    }
+  } catch (err) {
+    logger.error({ err, tool: name }, "evolution tool error");
+    return {
+      content: [{ type: "text", text: JSON.stringify({ error: String(err) }) }],
+      isError: true,
+    };
+  }
+}