claude-code-swarm 0.3.5 → 0.3.7

package/e2e/tier7-minimem.test.mjs

@@ -0,0 +1,461 @@
+/**
+ * Tier 7: Minimem Integration Tests
+ *
+ * Tests the minimem MCP server and integration without LLM calls:
+ *   1. MCP server starts and responds to tool calls
+ *   2. Memory search returns results for seeded files
+ *   3. AGENT.md generation includes minimem tool instructions
+ *   4. Bootstrap context output includes memory capability section
+ *   5. MCP wrapper script exits cleanly when disabled
+ *
+ * No LLM calls — exercises the MCP server, agent generation, and context output.
+ *
+ * Run:
+ *   npx vitest run --config e2e/vitest.config.e2e.mjs e2e/tier7-minimem.test.mjs
+ */
+
+import { describe, it, expect, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { createWorkspace } from "./helpers/workspace.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_DIR = path.resolve(__dirname, "..");
+const SHORT_TMPDIR = "/tmp";
+
+// Check if minimem is available
+let minimemAvailable = false;
+try {
+  await import("minimem");
+  minimemAvailable = true;
+} catch {
+  // Not installed
+}
+
+// Import source modules for direct testing
+const { buildCapabilitiesContext } = await import("../src/context-output.mjs");
+const { generateAgentMd } = await import("../src/agent-generator.mjs");
+
+/**
+ * Start a minimem MCP server process and return a handle for JSON-RPC communication.
+ */
+function startMinimemMcp(memoryDir, options = {}) {
+  return new Promise((resolve, reject) => {
+    const args = ["mcp", "--dir", memoryDir, "--provider", options.provider || "none"];
+    if (options.global) args.push("--global");
+
+    const child = spawn("minimem", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env },
+    });
+
+    let stderr = "";
+    child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+    // MCP uses stdin/stdout JSON-RPC — give it a moment to start
+    const timer = setTimeout(() => {
+      resolve({
+        child,
+        stderr: () => stderr,
+        send: (request) => sendMcpRequest(child, request),
+        cleanup: () => { child.kill(); },
+      });
+    }, 1000);
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (code !== null && code !== 0) {
+        reject(new Error(`minimem mcp exited with code ${code}: ${stderr}`));
+      }
+    });
+  });
+}
+
+/**
+ * Send a JSON-RPC request to the MCP server via stdin and read response from stdout.
+ */
+function sendMcpRequest(child, request) {
+  return new Promise((resolve) => {
+    const id = request.id || Date.now();
+    const payload = JSON.stringify({
+      jsonrpc: "2.0",
+      id,
+      ...request,
+    });
+
+    let buffer = "";
+    const onData = (data) => {
+      buffer += data.toString();
+      // MCP uses Content-Length header framing or newline-delimited JSON
+      const lines = buffer.split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const response = JSON.parse(line);
+          if (response.id === id) {
+            child.stdout.removeListener("data", onData);
+            clearTimeout(timer);
+            resolve(response);
+            return;
+          }
+        } catch {
+          // Not complete JSON yet, or header line
+        }
+      }
+    };
+
+    child.stdout.on("data", onData);
+    child.stdin.write(payload + "\n");
+
+    const timer = setTimeout(() => {
+      child.stdout.removeListener("data", onData);
+      resolve(null); // Timeout
+    }, 5000);
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Group 1: Context Output — buildCapabilitiesContext includes minimem
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe(
+  "tier7: minimem context output",
+  { timeout: 30_000 },
+  () => {
+    it("buildCapabilitiesContext includes memory section when enabled + ready", () => {
+      const context = buildCapabilitiesContext({
+        minimemEnabled: true,
+        minimemStatus: "ready",
+      });
+
+      expect(context).toContain("### Memory");
+      expect(context).toContain("minimem__memory_search");
+      expect(context).toContain("minimem__memory_get_details");
+      expect(context).toContain("minimem__knowledge_search");
+      expect(context).toContain("minimem__knowledge_graph");
+      expect(context).toContain("minimem__knowledge_path");
+    });
+
+    it("buildCapabilitiesContext shows status when installed but not ready", () => {
+      const context = buildCapabilitiesContext({
+        minimemEnabled: true,
+        minimemStatus: "installed",
+      });
+
+      expect(context).toContain("### Memory");
+      expect(context).toContain("installed");
+      // Should not show full tool instructions
+      expect(context).not.toContain("minimem__memory_search");
+    });
+
+    it("buildCapabilitiesContext omits memory section when disabled", () => {
+      const context = buildCapabilitiesContext({
+        minimemEnabled: false,
+        minimemStatus: "disabled",
+      });
+
+      expect(context).not.toContain("### Memory");
+      expect(context).not.toContain("minimem");
+    });
+
+    it("main agent context includes storage instructions", () => {
+      const context = buildCapabilitiesContext({
+        role: null, // main agent
+        minimemEnabled: true,
+        minimemStatus: "ready",
+      });
+
+      expect(context).toContain("Storing memories");
+      expect(context).toContain("MEMORY.md");
+      expect(context).toContain("Team strategy");
+    });
+
+    it("spawned agent context omits storage section but has search guidance", () => {
+      const context = buildCapabilitiesContext({
+        role: "executor",
+        teamName: "gsd",
+        minimemEnabled: true,
+        minimemStatus: "ready",
+      });
+
+      expect(context).not.toContain("Storing memories");
+      expect(context).toContain("Before major work");
+      expect(context).toContain("After completing work");
+    });
+  }
+);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Group 2: Agent Generation — AGENT.md includes minimem tools
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe(
+  "tier7: minimem agent generation",
+  { timeout: 30_000 },
+  () => {
+    it("generateAgentMd includes minimem capabilities when enabled", () => {
+      const md = generateAgentMd({
+        roleName: "executor",
+        teamName: "gsd",
+        position: "spawned",
+        description: "Executor agent",
+        tools: ["Read", "Write", "Bash"],
+        skillContent: "# Role: executor\n\nTest content.",
+        manifest: {},
+        minimemEnabled: true,
+        minimemStatus: "ready",
+      });
+
+      expect(md).toContain("### Memory");
+      expect(md).toContain("minimem__memory_search");
+    });
+
+    it("generateAgentMd omits minimem when disabled", () => {
+      const md = generateAgentMd({
+        roleName: "executor",
+        teamName: "gsd",
+        position: "spawned",
+        description: "Executor agent",
+        tools: ["Read", "Write", "Bash"],
+        skillContent: "# Role: executor\n\nTest content.",
+        manifest: {},
+        minimemEnabled: false,
+      });
+
+      expect(md).not.toContain("### Memory");
+      expect(md).not.toContain("minimem");
+    });
+  }
+);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Group 3: MCP Wrapper Script — exits cleanly when disabled
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe(
+  "tier7: minimem MCP wrapper script",
+  { timeout: 15_000 },
+  () => {
+    let workspace;
+
+    afterEach(() => {
+      if (workspace) {
+        workspace.cleanup();
+        workspace = null;
+      }
+    });
+
+    it("run-minimem-mcp.sh exits 0 when minimem is disabled", async () => {
+      workspace = createWorkspace({
+        tmpdir: SHORT_TMPDIR,
+        prefix: "t7-mm-script-",
+        config: {
+          template: "gsd",
+          minimem: { enabled: false },
+        },
+      });
+
+      const result = await new Promise((resolve) => {
+        const child = spawn("bash", [
+          path.join(PLUGIN_DIR, ".claude-plugin", "run-minimem-mcp.sh"),
+        ], {
+          cwd: workspace.dir,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => { stdout += d.toString(); });
+        child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+        child.on("close", (code) => {
+          resolve({ code, stdout, stderr });
+        });
+
+        setTimeout(() => {
+          child.kill();
+          resolve({ code: -1, stdout, stderr });
+        }, 10000);
+      });
+
+      expect(result.code).toBe(0);
+    });
+
+    it("run-minimem-mcp.sh exits 0 when no config file exists", async () => {
+      workspace = createWorkspace({
+        tmpdir: SHORT_TMPDIR,
+        prefix: "t7-mm-noconf-",
+        // No config at all
+      });
+
+      const result = await new Promise((resolve) => {
+        const child = spawn("bash", [
+          path.join(PLUGIN_DIR, ".claude-plugin", "run-minimem-mcp.sh"),
+        ], {
+          cwd: workspace.dir,
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (d) => { stdout += d.toString(); });
+        child.stderr.on("data", (d) => { stderr += d.toString(); });
+
+        child.on("close", (code) => {
+          resolve({ code, stdout, stderr });
+        });
+
+        setTimeout(() => {
+          child.kill();
+          resolve({ code: -1, stdout, stderr });
+        }, 10000);
+      });
+
+      expect(result.code).toBe(0);
+    });
+  }
+);
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Group 4: MCP Server — starts and responds to tool listing
+// ─────────────────────────────────────────────────────────────────────────────
+
+describe.skipIf(!minimemAvailable)(
+  "tier7: minimem MCP server",
+  { timeout: 30_000 },
+  () => {
+    let workspace;
+    let mcpHandle;
+
+    afterEach(async () => {
+      if (mcpHandle) {
+        mcpHandle.cleanup();
+        mcpHandle = null;
+      }
+      if (workspace) {
+        workspace.cleanup();
+        workspace = null;
+      }
+    });
+
+    it("minimem mcp process starts without error", async () => {
+      workspace = createWorkspace({
+        tmpdir: SHORT_TMPDIR,
+        prefix: "t7-mm-mcp-",
+        config: { template: "gsd", minimem: { enabled: true } },
+      });
+
+      // Create memory dir
+      const memDir = path.join(workspace.dir, ".swarm", "minimem");
+      fs.mkdirSync(memDir, { recursive: true });
+
+      mcpHandle = await startMinimemMcp(memDir);
+      expect(mcpHandle.child.pid).toBeGreaterThan(0);
+
+      // Process should still be alive
+      expect(mcpHandle.child.exitCode).toBeNull();
+    });
+
+    it("memory search on empty store returns empty results", async () => {
+      workspace = createWorkspace({
+        tmpdir: SHORT_TMPDIR,
+        prefix: "t7-mm-search-",
+        config: { template: "gsd", minimem: { enabled: true } },
+      });
+
+      const memDir = path.join(workspace.dir, ".swarm", "minimem");
+      fs.mkdirSync(memDir, { recursive: true });
+
+      mcpHandle = await startMinimemMcp(memDir);
+
+      // Send MCP initialize first
+      const initResp = await mcpHandle.send({
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "test", version: "1.0" },
+        },
+      });
+      console.log("[tier7] MCP init response:", JSON.stringify(initResp));
+
+      if (initResp) {
+        // List tools to verify memory_search is available
+        const toolsResp = await mcpHandle.send({
+          method: "tools/list",
+          params: {},
+        });
+        console.log("[tier7] MCP tools:", JSON.stringify(toolsResp?.result?.tools?.map(t => t.name)));
+
+        if (toolsResp?.result?.tools) {
+          const toolNames = toolsResp.result.tools.map((t) => t.name);
+          expect(toolNames).toContain("memory_search");
+        }
+      }
+    });
+
+    it("seeded memory file is findable via search", async () => {
+      workspace = createWorkspace({
+        tmpdir: SHORT_TMPDIR,
+        prefix: "t7-mm-seed-",
+        config: { template: "gsd", minimem: { enabled: true } },
+      });
+
+      const memDir = path.join(workspace.dir, ".swarm", "minimem");
+      fs.mkdirSync(memDir, { recursive: true });
+
+      // Seed a memory file
+      fs.writeFileSync(
+        path.join(memDir, "test-decision.md"),
+        [
+          "### 2026-03-18 10:00",
+          "<!-- type: decision -->",
+          "We decided to use PostgreSQL for the user database because of its",
+          "strong JSON support and concurrent write performance.",
+        ].join("\n")
+      );
+
+      mcpHandle = await startMinimemMcp(memDir);
+
+      // Initialize MCP
+      const initResp = await mcpHandle.send({
+        method: "initialize",
+        params: {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "test", version: "1.0" },
+        },
+      });
+
+      if (!initResp) {
+        console.log("[tier7] MCP init failed — skipping search test");
+        return;
+      }
+
+      // Search for the seeded content
+      const searchResp = await mcpHandle.send({
+        method: "tools/call",
+        params: {
+          name: "memory_search",
+          arguments: { query: "PostgreSQL database decision" },
+        },
+      });
+
+      console.log("[tier7] search response:", JSON.stringify(searchResp?.result));
+
+      if (searchResp?.result) {
+        // Should find the seeded file
+        const content = JSON.stringify(searchResp.result);
+        const found = content.includes("PostgreSQL") || content.includes("test-decision");
+        console.log("[tier7] found seeded memory:", found);
+      }
+    });
+  }
+);