mnemos-capture 1.2.0 → 1.2.1

package/README.md

@@ -12,13 +12,26 @@
 
 <p align="center"><strong>Capture anything. Your agents apply it.</strong></p>
 
-<p align="center">A knowledge pipeline that ingests the outside world and makes it directly actionable by any AI agent — over MCP.</p>
+<p align="center">
+  Humans consume information. Agents execute information.<br/>
+  <em>Mnemos converts one into the other.</em>
+</p>
+
+<p align="center">A knowledge pipeline that turns what you learn into actionable context for AI agents.</p>
+
+---
+
+Your agent only knows what it was trained on. It doesn't know the article you read this morning, the framework you found last week, or the decision you made last sprint.
+
+**Mnemos bridges that gap.**
+
+Capture an insight once. Mnemos extracts it, stores it as plain Markdown in your own GitHub repository, indexes it, and serves it to any MCP-compatible agent.
 
-Your agent only knows what it was trained on. It doesn't know the article you read this morning, the framework you found last week, or the decision you made last sprint. **Your AI agent finally knows what you've been reading.**
+Then it goes further. At session start, Mnemos briefs your agent on what matters right now, surfaces relevant knowledge in context, synthesizes reusable rules, and turns insights into implementation plans.
 
-Mnemos is the pipeline between the two. Capture any insight once — Mnemos extracts it, stores it as plain Markdown in your own GitHub repo, and serves it to your agent over MCP. Then it goes further: at session start it briefs your agent on what matters right now, turns insights into implementation plans, and hands them to whatever assistant you run — Claude Code, Codex, Cursor, Gemini, anything MCP-compatible.
+> **The result isn't another knowledge base.** It's a system that transforms what you learn into what your agents can execute.
 
-It's not a second brain, a vault, or a note-taking app — those store knowledge for *you* to read later. Mnemos makes knowledge your **agent acts on now**.
+<p align="center"><sub>Works with <strong>Claude Code</strong> · <strong>Codex</strong> · <strong>Cursor</strong> · <strong>Gemini</strong> · and any MCP-compatible assistant.</sub></p>
 
 
 ## Get started

package/dist/cli/mcp-server.js

@@ -2,8 +2,7 @@
 // Used by Claude Code: claude mcp add mnemos -- npx mnemos-capture serve-mcp --key <api-key>
 const HOSTED_URL = "https://mnemos-capture.vercel.app/api/mcp";
 function sendMessage(msg) {
-    const json = JSON.stringify(msg);
-    process.stdout.write(`Content-Length: ${Buffer.byteLength(json)}\r\n\r\n${json}`);
+    process.stdout.write(`${JSON.stringify(msg)}\n`);
 }
 async function proxyToHosted(apiKey, msg) {
     try {
@@ -62,31 +61,21 @@ export async function serveMcp() {
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => {
         buffer += chunk;
-        while (true) {
-            const headerEnd = buffer.indexOf("\r\n\r\n");
-            if (headerEnd === -1)
-                break;
-            const header = buffer.slice(0, headerEnd);
-            const match = header.match(/Content-Length:\s*(\d+)/i);
-            if (!match) {
-                buffer = buffer.slice(headerEnd + 4);
+        let newlineIdx;
+        while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, newlineIdx).trim();
+            buffer = buffer.slice(newlineIdx + 1);
+            if (!line)
                 continue;
-            }
-            const contentLength = parseInt(match[1], 10);
-            const bodyStart = headerEnd + 4;
-            if (buffer.length < bodyStart + contentLength)
-                break;
-            const body = buffer.slice(bodyStart, bodyStart + contentLength);
-            buffer = buffer.slice(bodyStart + contentLength);
             try {
-                const msg = JSON.parse(body);
+                const msg = JSON.parse(line);
                 // Handle notifications/initialized locally (no response needed)
                 if (msg.method === "notifications/initialized")
                     continue;
                 void proxyToHosted(apiKey, msg);
             }
             catch {
-                process.stderr.write(`Failed to parse: ${body}\n`);
+                process.stderr.write(`Failed to parse: ${line}\n`);
             }
         }
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mnemos-capture",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "Capture anything. Your agents apply it. A knowledge pipeline that ingests the outside world and makes it directly actionable by any AI agent over MCP.",
   "type": "module",
   "bin": {
@@ -13,7 +13,8 @@
     "build:cli": "tsc -p cli/tsconfig.json",
     "prepublishOnly": "npm run build:cli",
     "test": "vitest run",
-    "test:watch": "vitest"
+    "test:watch": "vitest",
+    "test:e2e": "playwright test"
   },
   "keywords": [
     "ai",
@@ -47,6 +48,7 @@
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
+    "@playwright/test": "^1.61.1",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",

package/dist/cli/__tests__/config.test.js

@@ -1,49 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, readFileSync, existsSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-describe("config", () => {
-    let tmpDir;
-    let configPath;
-    let origHome;
-    beforeEach(() => {
-        tmpDir = mkdtempSync(join(tmpdir(), "mnemos-config-test-"));
-        configPath = join(tmpDir, ".mnemos", "config.json");
-        origHome = process.env["HOME"];
-        process.env["HOME"] = tmpDir;
-        // Module-level CONFIG_DIR is computed from homedir() at import — reset cache
-        vi.resetModules();
-    });
-    afterEach(() => {
-        rmSync(tmpDir, { recursive: true, force: true });
-        process.env["HOME"] = origHome;
-    });
-    it("returns an empty object when no config exists", async () => {
-        const { readConfig } = await import("../config.js");
-        expect(readConfig()).toEqual({});
-    });
-    it("writes and reads back the agent field", async () => {
-        const { setConfigField, readConfig } = await import("../config.js");
-        setConfigField("agent", "claude -p");
-        expect(readConfig().agent).toBe("claude -p");
-        expect(existsSync(configPath)).toBe(true);
-    });
-    it("persists the agent command verbatim, including flags", async () => {
-        const { setConfigField } = await import("../config.js");
-        setConfigField("agent", "aider --yes --message");
-        const saved = JSON.parse(readFileSync(configPath, "utf-8"));
-        expect(saved.agent).toBe("aider --yes --message");
-    });
-    it("preserves other fields when updating one", async () => {
-        const { setConfigField, readConfig } = await import("../config.js");
-        setConfigField("key", "mnemos_abc123");
-        setConfigField("agent", "codex exec");
-        const cfg = readConfig();
-        expect(cfg.key).toBe("mnemos_abc123");
-        expect(cfg.agent).toBe("codex exec");
-    });
-    it("throws on an unknown config field", async () => {
-        const { setConfigField } = await import("../config.js");
-        expect(() => setConfigField("provider", "openai")).toThrow(/Unknown config field/);
-    });
-});

package/dist/cli/__tests__/hooks.test.js

@@ -1,276 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { mkdtempSync, rmSync, readFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-// ── Helpers ──────────────────────────────────────────────────────────────────
-/** Capture stdout writes during a callback. */
-async function captureStdout(fn) {
-    const chunks = [];
-    const orig = process.stdout.write.bind(process.stdout);
-    process.stdout.write = (chunk) => {
-        chunks.push(String(chunk));
-        return true;
-    };
-    try {
-        await fn();
-    }
-    finally {
-        process.stdout.write = orig;
-    }
-    return chunks.join("");
-}
-// ── setupHooks / setupPreToolHook ────────────────────────────────────────────
-describe("setupHooks", () => {
-    let tmpDir;
-    let settingsPath;
-    let origHome;
-    beforeEach(() => {
-        tmpDir = mkdtempSync(join(tmpdir(), "mnemos-test-"));
-        settingsPath = join(tmpDir, ".claude", "settings.json");
-        origHome = process.env["HOME"];
-        process.env["HOME"] = tmpDir;
-        // Clear module cache so CLAUDE_SETTINGS_PATH is recomputed with the new HOME
-        vi.resetModules();
-    });
-    afterEach(() => {
-        rmSync(tmpDir, { recursive: true, force: true });
-        process.env["HOME"] = origHome;
-    });
-    it("installs a SessionStart hook with the provided API key", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("my-api-key", { silent: true });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const cmd = settings.hooks.SessionStart[0]?.hooks[0]?.command ?? "";
-        expect(cmd).toContain("inbox-check");
-        expect(cmd).toContain("my-api-key");
-    });
-    it("includes --briefing flag when briefing option is true", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("key123", { silent: true, briefing: true });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const cmd = settings.hooks.SessionStart[0]?.hooks[0]?.command ?? "";
-        expect(cmd).toContain("--briefing");
-    });
-    it("omits --briefing flag when briefing option is false", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("key123", { silent: true, briefing: false });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const cmd = settings.hooks.SessionStart[0]?.hooks[0]?.command ?? "";
-        expect(cmd).not.toContain("--briefing");
-    });
-    it("also installs PreToolCall hook when vault option is true", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("vault-key", { silent: true, vault: true });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        expect(settings.hooks.PreToolCall).toBeDefined();
-        const cmd = settings.hooks.PreToolCall[0]?.hooks[0]?.command ?? "";
-        expect(cmd).toContain("vault-check");
-        expect(cmd).toContain("vault-key");
-    });
-    it("does NOT install PreToolCall hook when vault option is false", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("no-vault-key", { silent: true, vault: false });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        expect(settings.hooks["PreToolCall"]).toBeUndefined();
-    });
-    it("replaces an existing mnemos hook rather than duplicating it", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("old-key", { silent: true });
-        setupHooks("new-key", { silent: true });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const cmds = settings.hooks.SessionStart.flatMap((g) => g.hooks.map((h) => h.command));
-        const mnemosHooks = cmds.filter((c) => c.includes("inbox-check"));
-        expect(mnemosHooks).toHaveLength(1);
-        expect(mnemosHooks[0]).toContain("new-key");
-    });
-    it("skipIfExists: keeps exactly one mnemos hook when called twice", async () => {
-        const { setupHooks } = await import("../hooks.js");
-        setupHooks("original-key", { silent: true });
-        setupHooks("different-key", { silent: true, skipIfExists: true });
-        const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-        const cmds = settings.hooks.SessionStart.flatMap((g) => g.hooks.map((h) => h.command));
-        expect(cmds.filter((c) => c.includes("inbox-check"))).toHaveLength(1);
-    });
-});
-// ── inboxCheck — briefing mode parsing ───────────────────────────────────────
-describe("inboxCheck — briefing mode", () => {
-    let fetchSpy;
-    beforeEach(() => {
-        fetchSpy = vi.spyOn(globalThis, "fetch");
-    });
-    afterEach(() => {
-        fetchSpy.mockRestore();
-    });
-    function makeMcpResponse(text) {
-        return Promise.resolve(new Response(JSON.stringify({ result: { content: [{ text }] } }), { status: 200, headers: { "Content-Type": "application/json" } }));
-    }
-    it("strips the JSON block from display output", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse(`\`\`\`json
-[{"filename":"inbox/a.md","why":"x","benefit":"y","where":"z.ts","applyNow":true}]
-\`\`\`
-
-## Relevant Rules
-None applicable.`));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key", { briefing: true }));
-        expect(output).not.toContain("```json");
-        expect(output).toContain("## Relevant Rules");
-    });
-    it("appends generate_plan prompt when there are applyNow suggestions", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse(`\`\`\`json
-[{"filename":"inbox/a.md","why":"x","benefit":"y","where":"z.ts","applyNow":true}]
-\`\`\`
-
-## Apply Now
-One insight.`));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key", { briefing: true }));
-        expect(output).toContain("generate_plan");
-        expect(output).toContain("inbox/a.md");
-    });
-    it("does NOT append generate_plan prompt when all suggestions have applyNow=false", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse(`\`\`\`json
-[{"filename":"inbox/b.md","why":"x","benefit":"y","where":"z.ts","applyNow":false}]
-\`\`\`
-
-## Knowledge Vault
-One vault item.`));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key", { briefing: true }));
-        expect(output).not.toContain("generate_plan");
-    });
-    it("does NOT append generate_plan prompt when JSON block is missing", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse(`## Relevant Rules
-None applicable.`));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key", { briefing: true }));
-        expect(output).not.toContain("generate_plan");
-    });
-    it("shows inbox count in non-briefing mode when count > 0", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse("3 capture(s) in inbox:\n\n1. file.md"));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key"));
-        expect(output).toContain("3");
-        expect(output).toContain("inbox");
-    });
-    it("shows nothing in non-briefing mode when inbox is empty", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse("Inbox is empty."));
-        const { inboxCheck } = await import("../hooks.js");
-        const output = await captureStdout(() => inboxCheck("key"));
-        expect(output).toBe("");
-    });
-    it("silently fails when fetch throws", async () => {
-        fetchSpy.mockRejectedValue(new Error("Network error"));
-        const { inboxCheck } = await import("../hooks.js");
-        // Should not throw
-        await expect(inboxCheck("key", { briefing: true })).resolves.toBeUndefined();
-    });
-});
-// ── vaultCheck — stdin parsing ────────────────────────────────────────────────
-describe("vaultCheck", () => {
-    let fetchSpy;
-    let origSessionId;
-    beforeEach(() => {
-        fetchSpy = vi.spyOn(globalThis, "fetch");
-        origSessionId = process.env["CLAUDE_SESSION_ID"];
-        // Use a unique session ID per test to avoid state pollution
-        process.env["CLAUDE_SESSION_ID"] = `test-${Date.now()}-${Math.random()}`;
-    });
-    afterEach(() => {
-        fetchSpy.mockRestore();
-        process.env["CLAUDE_SESSION_ID"] = origSessionId;
-    });
-    function makeMcpResponse(text) {
-        return Promise.resolve(new Response(JSON.stringify({ result: { content: [{ text }] } }), { status: 200, headers: { "Content-Type": "application/json" } }));
-    }
-    it("outputs vault match when fetch returns a high-score match", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse("Mnemos vault match (score: 87%):\n\n**2026-05-01-error-ctx**\nCore idea here.\n- Key takeaway\n\nApply it? Run: `apply_capture` with filename: `inbox/2026-05-01-error-ctx.md`"));
-        const { vaultCheck } = await import("../hooks.js");
-        // Simulate piped stdin with an Edit tool call
-        const hookData = JSON.stringify({
-            tool_name: "Edit",
-            tool_input: { file_path: "src/api/capture/route.ts" },
-        });
-        // Temporarily replace stdin
-        const mockStdin = {
-            isTTY: false,
-            setEncoding: vi.fn(),
-            on: vi.fn((event, cb) => {
-                if (event === "data")
-                    cb(hookData);
-                if (event === "end")
-                    cb();
-            }),
-        };
-        const origStdin = process.stdin;
-        Object.defineProperty(process, "stdin", { value: mockStdin, writable: true, configurable: true });
-        const output = await captureStdout(() => vaultCheck("key"));
-        Object.defineProperty(process, "stdin", { value: origStdin, writable: true, configurable: true });
-        expect(output).toContain("vault match");
-    });
-    it("outputs nothing when vault_scan returns empty", async () => {
-        fetchSpy.mockReturnValue(makeMcpResponse(""));
-        const { vaultCheck } = await import("../hooks.js");
-        const mockStdin = {
-            isTTY: false,
-            setEncoding: vi.fn(),
-            on: vi.fn((event, cb) => {
-                if (event === "data")
-                    cb(JSON.stringify({ tool_name: "Edit", tool_input: { file_path: "src/foo.ts" } }));
-                if (event === "end")
-                    cb();
-            }),
-        };
-        const origStdin = process.stdin;
-        Object.defineProperty(process, "stdin", { value: mockStdin, writable: true, configurable: true });
-        const output = await captureStdout(() => vaultCheck("key"));
-        Object.defineProperty(process, "stdin", { value: origStdin, writable: true, configurable: true });
-        expect(output).toBe("");
-    });
-    it("outputs nothing and does not call fetch when tool is not an editing tool", async () => {
-        const { vaultCheck } = await import("../hooks.js");
-        const mockStdin = {
-            isTTY: false,
-            setEncoding: vi.fn(),
-            on: vi.fn((event, cb) => {
-                if (event === "data")
-                    cb(JSON.stringify({ tool_name: "Bash", tool_input: { command: "ls" } }));
-                if (event === "end")
-                    cb();
-            }),
-        };
-        const origStdin = process.stdin;
-        Object.defineProperty(process, "stdin", { value: mockStdin, writable: true, configurable: true });
-        await vaultCheck("key");
-        Object.defineProperty(process, "stdin", { value: origStdin, writable: true, configurable: true });
-        expect(fetchSpy).not.toHaveBeenCalled();
-    });
-    it("outputs nothing when stdin is a TTY (not piped)", async () => {
-        const { vaultCheck } = await import("../hooks.js");
-        const mockStdin = { isTTY: true };
-        const origStdin = process.stdin;
-        Object.defineProperty(process, "stdin", { value: mockStdin, writable: true, configurable: true });
-        const output = await captureStdout(() => vaultCheck("key"));
-        Object.defineProperty(process, "stdin", { value: origStdin, writable: true, configurable: true });
-        expect(output).toBe("");
-        expect(fetchSpy).not.toHaveBeenCalled();
-    });
-    it("silently fails when fetch throws", async () => {
-        fetchSpy.mockRejectedValue(new Error("Network error"));
-        const { vaultCheck } = await import("../hooks.js");
-        const mockStdin = {
-            isTTY: false,
-            setEncoding: vi.fn(),
-            on: vi.fn((event, cb) => {
-                if (event === "data")
-                    cb(JSON.stringify({ tool_name: "Edit", tool_input: { file_path: "src/foo.ts" } }));
-                if (event === "end")
-                    cb();
-            }),
-        };
-        const origStdin = process.stdin;
-        Object.defineProperty(process, "stdin", { value: mockStdin, writable: true, configurable: true });
-        await expect(vaultCheck("key")).resolves.toBeUndefined();
-        Object.defineProperty(process, "stdin", { value: origStdin, writable: true, configurable: true });
-    });
-});

package/dist/cli/__tests__/kos.test.js

@@ -1,65 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parsePlanFilenames, latestPlanFilename, parseChecklist, buildKosBranch, } from "../kos.js";
-const LIST_PLANS = `3 plan(s):
-
-- **2026-06-03-plan-error-handling.md**: Implementation Plan: Error Handling
-- **2026-06-05-plan-provider-abstraction.md**: Implementation Plan: Provider Abstraction
-- **2026-06-04-plan-vault.md**: Implementation Plan: Vault`;
-describe("parsePlanFilenames", () => {
-    it("extracts all bolded plan filenames", () => {
-        expect(parsePlanFilenames(LIST_PLANS)).toEqual([
-            "2026-06-03-plan-error-handling.md",
-            "2026-06-05-plan-provider-abstraction.md",
-            "2026-06-04-plan-vault.md",
-        ]);
-    });
-    it("returns empty array when there are no plans", () => {
-        expect(parsePlanFilenames("No plans saved yet.")).toEqual([]);
-    });
-});
-describe("latestPlanFilename", () => {
-    it("returns the newest plan by date prefix", () => {
-        expect(latestPlanFilename(LIST_PLANS)).toBe("2026-06-05-plan-provider-abstraction.md");
-    });
-    it("returns null when there are no plans", () => {
-        expect(latestPlanFilename("No plans saved yet.")).toBeNull();
-    });
-});
-describe("parseChecklist", () => {
-    const PLAN = `# Implementation Plan: Foo
-
-## Codebase Mapping
-| File | Capture | Change | Complexity | Effort |
-|------|---------|--------|------------|--------|
-| a.ts | x | edit | simple | low |
-
-## Verification Checklist
-- [ ] Error messages include a handler prefix
-- [ ] No regressions in the happy path
-- [x] Already-done item still counts
-
-## Notes
-Not part of the checklist.`;
-    it("extracts checklist items without the checkbox prefix", () => {
-        expect(parseChecklist(PLAN)).toEqual([
-            "Error messages include a handler prefix",
-            "No regressions in the happy path",
-            "Already-done item still counts",
-        ]);
-    });
-    it("stops at the next section heading", () => {
-        expect(parseChecklist(PLAN)).not.toContain("Not part of the checklist.");
-    });
-    it("returns empty array when there is no checklist section", () => {
-        expect(parseChecklist("# Plan\n\n## Context\nNothing here.")).toEqual([]);
-    });
-});
-describe("buildKosBranch", () => {
-    it("produces a deterministic, sortable branch name from a date", () => {
-        const branch = buildKosBranch(new Date("2026-06-05T10:30:45.000Z"));
-        expect(branch).toBe("mnemos/kos-2026-06-05-10-30-45");
-    });
-    it("always starts with the mnemos/kos- prefix", () => {
-        expect(buildKosBranch()).toMatch(/^mnemos\/kos-/);
-    });
-});