@mclawnet/mcp-server 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mclawnet/mcp-server",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "exports": {
     ".": {
@@ -12,11 +12,17 @@
   "bin": {
     "clawnet-mcp": "dist/server.js"
   },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "@mclawnet/logger": "0.1.2",
-    "@mclawnet/skill-manager": "0.1.0",
-    "@mclawnet/memory": "0.1.1"
+    "@mclawnet/logger": "0.1.4",
+    "@mclawnet/memory": "0.1.3",
+    "@mclawnet/skill-manager": "0.1.2"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7",

package/src/__tests__/e2e-memory-pipeline.test.ts

@@ -1,627 +0,0 @@
-/**
- * E2E Memory Pipeline Test
- *
- * Tests the full memory lifecycle as it flows through a swarm session:
- *   1. Role stores memories via MCP tools (Pipeline B)
- *   2. Swarm retrospective writes collaboration memories + role_stats
- *   3. AutoMemorySync exports to auto memory files
- *   4. buildMemorySection reads working memories for prompt injection (Pipeline A)
- *   5. Distillation extracts experience from conversations
- */
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { mkdtempSync, rmSync, readFileSync, existsSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import type { Database as DatabaseType } from "better-sqlite3";
-
-import {
-  buildMemorySection,
-  distillConversation,
-  EmbeddingService,
-  initDatabase,
-  MemoryStore,
-  syncToAutoMemory,
-} from "@mclawnet/memory";
-import {
-  handleMemoryToolCall,
-  type MemoryToolContext,
-} from "../tools/memory.js";
-
-// In the original memory package, ToolContext carried roleId. The mcp-server
-// API accepts roleId per call. Adapt by wrapping the call site so existing
-// test logic stays unchanged.
-type ToolContext = MemoryToolContext & { roleId: string };
-
-function handleToolCall(
-  name: string,
-  args: Record<string, unknown>,
-  ctx: ToolContext,
-) {
-  const merged = { roleId: ctx.roleId, ...args };
-  return handleMemoryToolCall(name, merged, { store: ctx.store, embeddingService: ctx.embeddingService });
-}
-
-// ── Shared state ──────────────────────────────────────────────────────
-
-let db: DatabaseType;
-let store: MemoryStore;
-let embeddingService: EmbeddingService;
-let tmpDir: string;
-let dbPath: string;
-let memoryDir: string;
-
-// Contexts for different roles
-let devCtx: ToolContext;
-let queenCtx: ToolContext;
-
-// Track stored memory IDs for later assertions
-const storedIds: string[] = [];
-
-beforeAll(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), "e2e-memory-pipeline-"));
-  dbPath = join(tmpDir, "test.db");
-  memoryDir = join(tmpDir, "auto-memory");
-
-  db = initDatabase(dbPath);
-  store = new MemoryStore(db);
-  embeddingService = new EmbeddingService(db);
-
-  devCtx = { store, embeddingService, roleId: "role-developer" };
-  queenCtx = { store, embeddingService, roleId: "role-queen" };
-});
-
-afterAll(() => {
-  db.close();
-  if (existsSync(tmpDir)) {
-    rmSync(tmpDir, { recursive: true });
-  }
-});
-
-// ── Full lifecycle ────────────────────────────────────────────────────
-
-describe("Memory Pipeline E2E", () => {
-  it("full lifecycle: store -> search -> retrospective -> sync -> prompt inject", async () => {
-    // ── Step 1: Store 3 memories via MCP handleToolCall ──────────────
-
-    const mem1 = await handleToolCall(
-      "memory_store",
-      {
-        content: "使用连接池提升性能3倍",
-        type: "experience",
-        domain: "backend",
-        importance: 0.8,
-      },
-      devCtx,
-    );
-    const parsed1 = JSON.parse(mem1.content[0].text);
-    expect(parsed1.success).toBe(true);
-    storedIds.push(parsed1.id);
-
-    const mem2 = await handleToolCall(
-      "memory_store",
-      {
-        content: "不要在WAL模式下vacuum",
-        type: "error",
-        domain: "database",
-        importance: 0.9,
-      },
-      devCtx,
-    );
-    const parsed2 = JSON.parse(mem2.content[0].text);
-    expect(parsed2.success).toBe(true);
-    storedIds.push(parsed2.id);
-
-    const mem3 = await handleToolCall(
-      "memory_store",
-      {
-        content: "ESM优先于CJS",
-        type: "preference",
-        domain: "tooling",
-        importance: 0.6,
-      },
-      devCtx,
-    );
-    const parsed3 = JSON.parse(mem3.content[0].text);
-    expect(parsed3.success).toBe(true);
-    storedIds.push(parsed3.id);
-
-    // ── Step 2: Search "数据库" finds related memory ─────────────────
-
-    const searchResult = await handleToolCall(
-      "memory_search",
-      { query: "数据库性能" },
-      devCtx,
-    );
-    expect(searchResult.isError).toBeUndefined();
-    const searchParsed = JSON.parse(searchResult.content[0].text);
-    expect(searchParsed).toBeInstanceOf(Array);
-    expect(searchParsed.length).toBeGreaterThan(0);
-
-    // ── Step 3: memory_stats returns correct statistics ──────────────
-
-    const statsResult = await handleToolCall("memory_stats", {}, devCtx);
-    const stats = JSON.parse(statsResult.content[0].text);
-    expect(stats.totalMemories).toBe(3);
-    expect(stats.byType.experience).toBe(1);
-    expect(stats.byType.error).toBe(1);
-    expect(stats.byType.preference).toBe(1);
-    expect(stats.topDomains.length).toBeGreaterThanOrEqual(3);
-
-    // ── Step 4: Simulate swarm retrospective (manual persistToDb) ───
-    //    Write collaboration memories as the queen role + populate role_stats
-
-    await store.addMemoryWithEmbedding(
-      {
-        roleId: "role-queen",
-        content: "Developer与Reviewer并行工作效率最高",
-        type: "pattern",
-        level: "long-term",
-        domain: "collaboration",
-        importance: 0.85,
-        sourceSwarmIds: ["swarm-test-001"],
-      },
-      embeddingService,
-    );
-
-    await store.addMemoryWithEmbedding(
-      {
-        roleId: "role-queen",
-        content: "分阶段交付比一次性交付风险更低",
-        type: "experience",
-        level: "long-term",
-        domain: "collaboration",
-        importance: 0.75,
-        sourceSwarmIds: ["swarm-test-001"],
-      },
-      embeddingService,
-    );
-
-    // Write role_stats directly
-    db.prepare(
-      `INSERT OR REPLACE INTO role_stats
-       (role_id, tasks_completed, tasks_failed, avg_quality_score, avg_rework_count, total_memories, domains, updated_at)
-       VALUES (@roleId, @completed, @failed, @quality, @rework, @total, @domains, @now)`,
-    ).run({
-      roleId: "role-developer",
-      completed: 5,
-      failed: 1,
-      quality: 0.85,
-      rework: 0.2,
-      total: 3,
-      domains: JSON.stringify(["backend", "database", "tooling"]),
-      now: Date.now(),
-    });
-
-    // Verify collaboration memories are in DB
-    const collabMemories = store.getMemoriesByRole("role-queen");
-    const collabDomainMemories = collabMemories.filter((m) => m.domain === "collaboration");
-    expect(collabDomainMemories.length).toBeGreaterThanOrEqual(2);
-
-    // Verify role_stats has data
-    const roleStatsRow = db
-      .prepare("SELECT * FROM role_stats WHERE role_id = ?")
-      .get("role-developer") as Record<string, unknown> | undefined;
-    expect(roleStatsRow).toBeDefined();
-    expect(roleStatsRow!.tasks_completed).toBe(5);
-
-    // ── Step 5: syncToAutoMemory -> verify output files ──────────────
-
-    const syncResult = syncToAutoMemory(db, {
-      projectPath: "/test-project",
-      memoryDir,
-    });
-
-    expect(syncResult.filesWritten).toContain("MEMORY.md");
-    expect(syncResult.totalEntries).toBeGreaterThanOrEqual(4);
-
-    // Verify errors.md contains our WAL vacuum memory
-    expect(syncResult.filesWritten).toContain("errors.md");
-    const errorsContent = readFileSync(join(memoryDir, "errors.md"), "utf-8");
-    expect(errorsContent).toContain("不要在WAL模式下vacuum");
-
-    // Verify patterns.md contains our connection pool experience
-    expect(syncResult.filesWritten).toContain("patterns.md");
-    const patternsContent = readFileSync(join(memoryDir, "patterns.md"), "utf-8");
-    expect(patternsContent).toContain("使用连接池提升性能3倍");
-
-    // Verify collaboration.md contains retrospective memories
-    expect(syncResult.filesWritten).toContain("collaboration.md");
-    const collabContent = readFileSync(join(memoryDir, "collaboration.md"), "utf-8");
-    expect(collabContent).toContain("Developer与Reviewer并行工作效率最高");
-
-    // Verify MEMORY.md index has "Top Memories" and topic file links
-    const indexContent = readFileSync(join(memoryDir, "MEMORY.md"), "utf-8");
-    expect(indexContent).toContain("Top Memories");
-    expect(indexContent).toContain("[errors.md](./errors.md)");
-
-    // ── Step 6: Set memory to working level -> buildMemorySection ────
-
-    store.updateMemory(storedIds[0], { level: "working" }); // 连接池 experience
-    store.updateMemory(storedIds[1], { level: "working" }); // WAL vacuum error
-
-    // Close db before buildMemorySection (it opens its own connection)
-    db.close();
-
-    const section = buildMemorySection("role-developer", dbPath);
-    expect(section).toContain("使用连接池提升性能3倍");
-    expect(section).toContain("不要在WAL模式下vacuum");
-    // Should contain role-specific instructions
-    expect(section).toContain("## 开发者专属记忆指南");
-    // Should NOT have the raw placeholder
-    expect(section).not.toContain("{workingMemories}");
-
-    // Re-open db for subsequent tests
-    db = initDatabase(dbPath);
-    store = new MemoryStore(db);
-    embeddingService = new EmbeddingService(db);
-    devCtx = { store, embeddingService, roleId: "role-developer" };
-    queenCtx = { store, embeddingService, roleId: "role-queen" };
-  });
-
-  // ── Cross-role search ──────────────────────────────────────────────
-
-  it("cross-role search: developer finds queen collaboration memories", async () => {
-    // Search as developer with crossRole: true should find queen's collaboration memories
-    const result = await handleToolCall(
-      "memory_search",
-      { query: "协作模式并行工作", crossRole: true },
-      devCtx,
-    );
-
-    const parsed = JSON.parse(result.content[0].text);
-    expect(parsed.length).toBeGreaterThan(0);
-
-    // At least one result should be from queen and about collaboration
-    const queenResults = parsed.filter(
-      (m: { roleId: string }) => m.roleId === "role-queen",
-    );
-    expect(queenResults.length).toBeGreaterThan(0);
-  });
-
-  // ── Importance filter ──────────────────────────────────────────────
-
-  it("importance filter: low-importance excluded from sync", async () => {
-    // Store a low-importance memory
-    await store.addMemoryWithEmbedding(
-      {
-        roleId: "role-developer",
-        content: "低优先级记忆：临时调试信息",
-        type: "experience",
-        domain: "debug",
-        importance: 0.3,
-      },
-      embeddingService,
-    );
-
-    // Re-sync with default minImportance (0.5)
-    const secondMemoryDir = join(tmpDir, "auto-memory-filter");
-    const syncResult = syncToAutoMemory(db, {
-      projectPath: "/test-project",
-      memoryDir: secondMemoryDir,
-    });
-
-    // Low-importance memory should not appear in any output file
-    for (const filename of syncResult.filesWritten) {
-      const content = readFileSync(join(secondMemoryDir, filename), "utf-8");
-      expect(content).not.toContain("低优先级记忆：临时调试信息");
-    }
-  });
-
-  // ── Distillation roundtrip ─────────────────────────────────────────
-
-  it("distillation -> search roundtrip", async () => {
-    const messages = [
-      { role: "user", content: "这个部署脚本怎么写？" },
-      {
-        role: "assistant",
-        content:
-          "best practice: 部署脚本应该是幂等的，使用健康检查确认服务正常启动后再切流量",
-      },
-      { role: "user", content: "还有什么注意事项？" },
-      {
-        role: "assistant",
-        content: "注意：回滚策略必须提前准备好，不要等出问题才想",
-      },
-    ];
-
-    const distillResult = await distillConversation(
-      messages,
-      "role-developer",
-      store,
-      embeddingService,
-    );
-
-    expect(distillResult.extracted).toBeGreaterThanOrEqual(1);
-
-    // Now search for the distilled memory via MCP tool
-    const searchResult = await handleToolCall(
-      "memory_search",
-      { query: "部署脚本幂等健康检查" },
-      devCtx,
-    );
-
-    const parsed = JSON.parse(searchResult.content[0].text);
-    expect(parsed.length).toBeGreaterThan(0);
-    // At least one result should contain content from distillation
-    const hasDistilled = parsed.some(
-      (m: { content: string }) =>
-        m.content.includes("幂等") || m.content.includes("回滚"),
-    );
-    expect(hasDistilled).toBe(true);
-  });
-
-  // ── Idempotent sync ────────────────────────────────────────────────
-
-  it("idempotent sync: repeated sync produces same files", () => {
-    const idempotentDir = join(tmpDir, "auto-memory-idempotent");
-
-    const result1 = syncToAutoMemory(db, {
-      projectPath: "/test-project",
-      memoryDir: idempotentDir,
-    });
-    const files1 = result1.filesWritten.map((f) =>
-      readFileSync(join(idempotentDir, f), "utf-8"),
-    );
-
-    const result2 = syncToAutoMemory(db, {
-      projectPath: "/test-project",
-      memoryDir: idempotentDir,
-    });
-    const files2 = result2.filesWritten.map((f) =>
-      readFileSync(join(idempotentDir, f), "utf-8"),
-    );
-
-    expect(result1.filesWritten).toEqual(result2.filesWritten);
-    expect(result1.totalEntries).toEqual(result2.totalEntries);
-    expect(files1).toEqual(files2);
-  });
-});
-
-// ── Sprint 3+4 E2E Tests ─────────────────────────────────────────────
-
-describe("E2E: Fisher Fusion conflict detection", () => {
-  it("should detect and resolve duplicate content via MCP memory_store", async () => {
-    // Store a memory first
-    const result1 = await handleToolCall(
-      "memory_store",
-      { content: "Always use TypeScript strict mode", type: "pattern", importance: 0.6 },
-      devCtx,
-    );
-    const parsed1 = JSON.parse(result1.content[0].text);
-    expect(parsed1.success).toBe(true);
-    expect(parsed1.fusionAction).toBe("keep_both"); // first store, no conflict
-
-    // Store identical content — should trigger fusion
-    const result2 = await handleToolCall(
-      "memory_store",
-      { content: "Always use TypeScript strict mode", type: "pattern", importance: 0.7 },
-      devCtx,
-    );
-    const parsed2 = JSON.parse(result2.content[0].text);
-    expect(parsed2.success).toBe(true);
-    // With hash embeddings, identical text will have cosine=1.0, triggering conflict
-    // The resolution depends on fisherWeight comparison
-    expect(["keep_old", "keep_new", "merge"]).toContain(parsed2.fusionAction);
-  });
-
-  it("should keep_both for different content", async () => {
-    await handleToolCall(
-      "memory_store",
-      { content: "React hooks need dependency arrays", type: "pattern" },
-      devCtx,
-    );
-    const result = await handleToolCall(
-      "memory_store",
-      { content: "Database indexes improve query speed", type: "experience" },
-      devCtx,
-    );
-    const parsed = JSON.parse(result.content[0].text);
-    expect(parsed.fusionAction).toBe("keep_both");
-  });
-});
-
-describe("E2E: Importance pruning via memory_reflect", () => {
-  it("should prune working memories exceeding cap via light reflect", async () => {
-    // Add 55 working-level memories (WORKING_CAP = 50)
-    for (let i = 0; i < 55; i++) {
-      store.addMemory({
-        roleId: "role-developer",
-        content: `working memory item ${i}`,
-        type: "experience",
-        level: "working",
-        importance: 0.3 + (i % 10) * 0.05,
-      });
-    }
-
-    const result = await handleToolCall(
-      "memory_reflect",
-      { scope: "light" },
-      devCtx,
-    );
-
-    const parsed = JSON.parse(result.content[0].text);
-    expect(parsed.scope).toBe("light");
-    expect(parsed.demotedToLongTerm).toBeGreaterThan(0);
-    // After pruning, working count should be <= 50
-    const stats = store.getStats("role-developer");
-    expect(stats.byLevel.working).toBeLessThanOrEqual(50);
-  });
-
-  it("should recalculate importance and prune all roles via full reflect", async () => {
-    // Add memories for two different roles
-    for (let i = 0; i < 10; i++) {
-      store.addMemory({
-        roleId: "role-developer",
-        content: `dev memory ${i}`,
-        type: "experience",
-      });
-      store.addMemory({
-        roleId: "role-reviewer",
-        content: `reviewer memory ${i}`,
-        type: "pattern",
-      });
-    }
-
-    const result = await handleToolCall(
-      "memory_reflect",
-      { scope: "full" },
-      devCtx,
-    );
-
-    const parsed = JSON.parse(result.content[0].text);
-    expect(parsed.scope).toBe("full");
-    expect(parsed.recalculated).toBeGreaterThanOrEqual(20);
-    expect(parsed.rolesProcessed).toBeGreaterThanOrEqual(2);
-    expect(typeof parsed.profilesRefreshed).toBe("number");
-  });
-});
-
-describe("E2E: VectorIndex accelerated search", () => {
-  it("should return correct results using vector index fast path", async () => {
-    // Store several memories with embeddings via MCP
-    const topics = [
-      "React component lifecycle methods",
-      "Database connection pooling strategies",
-      "CSS grid layout techniques",
-      "Node.js stream processing patterns",
-      "Git branching workflow best practices",
-    ];
-
-    for (const topic of topics) {
-      await handleToolCall(
-        "memory_store",
-        { content: topic, type: "experience" },
-        devCtx,
-      );
-    }
-
-    // Search should use vectorIndex fast path (index has entries)
-    const result = await handleToolCall(
-      "memory_search",
-      { query: "React component lifecycle methods", limit: 3 },
-      devCtx,
-    );
-
-    const parsed = JSON.parse(result.content[0].text);
-    expect(parsed.length).toBeGreaterThan(0);
-    // The exact match should be first or near the top
-    expect(parsed[0].content).toBe("React component lifecycle methods");
-  });
-});
-
-describe("E2E: Consolidation full pipeline", () => {
-  it("should run full consolidation with drift check and domain balance", async () => {
-    // Use a dedicated role so domain percentages are not diluted by prior tests
-    const consolidationRole = "role-consolidation-test";
-
-    // Store memories with embeddings across domains
-    for (let i = 0; i < 12; i++) {
-      await store.addMemoryWithEmbedding(
-        {
-          roleId: consolidationRole,
-          content: `frontend pattern ${i}`,
-          type: "pattern",
-          domain: "frontend",
-        },
-        embeddingService,
-      );
-    }
-    // Add a few in a different domain
-    for (let i = 0; i < 3; i++) {
-      await store.addMemoryWithEmbedding(
-        {
-          roleId: consolidationRole,
-          content: `backend experience ${i}`,
-          type: "experience",
-          domain: "backend",
-        },
-        embeddingService,
-      );
-    }
-
-    // Run consolidation
-    const { runConsolidation } = await import("@mclawnet/memory");
-    const result = await runConsolidation(db, {
-      vectorIndex: store.getVectorIndex(),
-      domainBalanceWarningThreshold: 0.7,
-    });
-
-    expect(result.rolesProcessed).toBeGreaterThan(0);
-    expect(result.recalculated).toBeGreaterThanOrEqual(15);
-    // 12/15 = 80% frontend on consolidationRole, should trigger domain warning
-    const frontendWarning = result.domainWarnings.find(
-      (w) => w.roleId === consolidationRole && w.domain === "frontend",
-    );
-    expect(frontendWarning).toBeDefined();
-    expect(frontendWarning!.percentage).toBeGreaterThan(0.7);
-    expect(typeof result.profilesRefreshed).toBe("number");
-  });
-});
-
-describe("E2E: EWC++ drift protection", () => {
-  it("should protect high-drift memories from pruning during consolidation", async () => {
-    const { EWCGuard } = await import("@mclawnet/memory");
-    const { runConsolidation } = await import("@mclawnet/memory");
-    const { WORKING_CAP } = await import("@mclawnet/memory");
-
-    const roleId = "role-ewc-drift-test";
-
-    // Step 1: Store initial memories with a consistent "direction" and compute profile
-    for (let i = 0; i < 5; i++) {
-      await store.addMemoryWithEmbedding(
-        {
-          roleId,
-          content: `core principle ${i} for role stability`,
-          type: "principle",
-          importance: 0.9,
-        },
-        embeddingService,
-      );
-    }
-
-    // Manually set high fisher_weight on these memories so they anchor the profile
-    const initialMemories = store.getMemoriesByRole(roleId);
-    for (const mem of initialMemories) {
-      db.prepare("UPDATE memories SET fisher_weight = 1.0 WHERE id = ?").run(mem.id);
-    }
-
-    // Compute and save the initial cognitive profile
-    const ewcGuard = new EWCGuard(db);
-    const profile = ewcGuard.computeProfile(roleId);
-    expect(profile).not.toBeNull();
-    expect(profile!.memoryCount).toBe(5);
-
-    // Step 2: Add many working-level memories to exceed WORKING_CAP and trigger pruning
-    // These have low importance and different content direction
-    for (let i = 0; i < WORKING_CAP + 10; i++) {
-      store.addMemory({
-        roleId,
-        content: `disposable working item ${i}`,
-        type: "experience",
-        level: "working",
-        importance: 0.2,
-      });
-    }
-
-    // Step 3: Run consolidation — it should check drift and protect core memories
-    const result = await runConsolidation(db, {
-      vectorIndex: store.getVectorIndex(),
-    });
-
-    // Pruning should have demoted some working memories
-    expect(result.totalDemotedToLongTerm).toBeGreaterThan(0);
-
-    // Step 4: Verify that the original high-fisher-weight principle memories survived
-    const survivingMemories = store.getMemoriesByRole(roleId);
-    const principleMemories = survivingMemories.filter(
-      (m) => m.type === "principle" && m.content.includes("core principle"),
-    );
-    // All 5 core principles should still exist (protected by EWC or high importance)
-    expect(principleMemories.length).toBe(5);
-
-    // Step 5: Verify drift was checked for this role
-    expect(result.driftResults[roleId]).toBeDefined();
-    expect(typeof result.driftResults[roleId].driftLoss).toBe("number");
-    expect(typeof result.driftResults[roleId].isAcceptable).toBe("boolean");
-  });
-});