mnemos-capture 1.2.0 → 1.3.0

package/dist/cli/config.js

@@ -1,28 +1,47 @@
 /**
- * Mnemos CLI config — stores which AI assistant kos should drive, and an
- * optional API key, in ~/.mnemos/config.json. Provider/agent-agnostic: the
- * user tells Mnemos the exact command to launch their assistant.
+ * Xmu CLI config — stores which AI assistant kos should drive, and an
+ * optional API key, in ~/.xmu/config.json. Falls back to ~/.mnemos/config.json.
  */
 import { homedir } from "os";
 import { join } from "path";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
-const CONFIG_DIR = join(homedir(), ".mnemos");
-const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function xmuDir() {
+    return join(homedir(), ".xmu");
+}
+function legacyDir() {
+    return join(homedir(), ".mnemos");
+}
+function xmuPath() {
+    return join(xmuDir(), "config.json");
+}
+function legacyPath() {
+    return join(legacyDir(), "config.json");
+}
+/** Path we currently read from: new dir if present, else the mnemos fallback. */
+function readPath() {
+    if (existsSync(xmuPath()))
+        return xmuPath();
+    if (existsSync(legacyPath()))
+        return legacyPath();
+    return xmuPath();
+}
 const ALLOWED_FIELDS = ["agent", "key"];
 export function readConfig() {
-    if (!existsSync(CONFIG_PATH))
+    const path = readPath();
+    if (!existsSync(path))
         return {};
     try {
-        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+        return JSON.parse(readFileSync(path, "utf-8"));
     }
     catch {
         return {};
     }
 }
 export function writeConfig(cfg) {
-    if (!existsSync(CONFIG_DIR))
-        mkdirSync(CONFIG_DIR, { recursive: true });
-    writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+    const dir = xmuDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(xmuPath(), JSON.stringify(cfg, null, 2) + "\n");
 }
 export function setConfigField(field, value) {
     if (!ALLOWED_FIELDS.includes(field)) {
@@ -32,21 +51,21 @@ export function setConfigField(field, value) {
     cfg[field] = value;
     writeConfig(cfg);
 }
-/** Route `mnemos config <set|get> ...`. */
+/** Route `xmu config <set|get> ...`. */
 export function runConfigCommand(args) {
     const action = args[0];
     if (action === "set") {
         const field = args[1];
         const value = args.slice(2).join(" ");
         if (!field || !value) {
-            console.error('Usage: mnemos config set <field> <value>');
-            console.error('  e.g. mnemos config set agent "claude -p"');
+            console.error("Usage: xmu config set <field> <value>");
+            console.error('  e.g. xmu config set agent "claude -p"');
             process.exit(1);
         }
         try {
             setConfigField(field, value);
             console.log(`Set ${field} = ${value}`);
-            console.log(`Saved to ${CONFIG_PATH}`);
+            console.log(`Saved to ${xmuPath()}`);
         }
         catch (err) {
             console.error(err instanceof Error ? err.message : String(err));
@@ -65,6 +84,6 @@ export function runConfigCommand(args) {
         }
         return;
     }
-    console.error("Usage: mnemos config set|get <field> [value]");
+    console.error("Usage: xmu config set|get <field> [value]");
     process.exit(1);
 }

package/dist/cli/hooks.js

@@ -108,7 +108,7 @@ export function setupHooks(apiKey, opts = {}) {
     settings.hooks = { ...hooks, SessionStart: filtered };
     writeSettings(settings);
     if (!opts.silent) {
-        console.log("Mnemos inbox hook installed.");
+        console.log("Xmu inbox hook installed.");
         console.log(`Location: ${CLAUDE_SETTINGS_PATH}`);
         if (opts.briefing) {
             console.log("At the start of each Claude Code session you'll see a full project briefing.");
@@ -151,7 +151,7 @@ export function setupPreToolHook(apiKey, opts = {}) {
     settings.hooks = { ...hooks, PreToolCall: filtered };
     writeSettings(settings);
     if (!opts.silent) {
-        console.log("Mnemos vault hook installed (PreToolCall).");
+        console.log("Xmu vault hook installed (PreToolCall).");
         console.log("Your knowledge vault will surface relevant captures as you edit files.");
     }
 }
@@ -294,7 +294,7 @@ export async function inboxCheck(apiKey, opts = {}) {
             return;
         const count = parseInt(match[1], 10);
         if (count > 0) {
-            process.stdout.write(`Mnemos: ${count} capture${count === 1 ? "" : "s"} in inbox — run list_inbox to review\n`);
+            process.stdout.write(`Xmu: ${count} capture${count === 1 ? "" : "s"} in inbox — run list_inbox to review\n`);
         }
     }
     catch {

package/dist/cli/index.js

@@ -52,7 +52,7 @@ async function main() {
         const keyIdx = args.indexOf("--key");
         const apiKey = keyIdx !== -1 ? args[keyIdx + 1] : readConfig().key;
         if (!apiKey) {
-            console.error("No API key. Pass --key YOUR_KEY or store it: mnemos config set key YOUR_KEY");
+            console.error("No API key. Pass --key YOUR_KEY or store it: xmu config set key YOUR_KEY");
             process.exit(1);
         }
         const planIdx = args.indexOf("--plan");
@@ -62,13 +62,13 @@ async function main() {
     }
     // Default: open the hosted app
     console.log("");
-    console.log("  Mnemos — Knowledge capture for agentic workflows\n");
+    console.log("  Xmu — A knowledge graph for your AI workers\n");
     console.log(`  Open ${HOSTED_URL} to start capturing.`);
     console.log("");
     console.log("  First time? Sign in with GitHub — setup takes 30 seconds.");
     console.log("");
-    console.log("  Connect to Claude Code:");
-    console.log("  claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY");
+    console.log("  Connect an AI worker:");
+    console.log("  claude mcp add xmu -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY");
     console.log("");
     // Try to open the URL in the default browser
     const { exec } = await import("child_process");
@@ -77,31 +77,33 @@ async function main() {
 }
 function printHelp() {
     console.log(`
-  Mnemos — Knowledge capture for agentic workflows
+  Xmu — A knowledge graph for your AI workers
 
   Usage:
-    npx mnemos-capture                                         Open Mnemos in your browser
-    npx mnemos-capture serve-mcp --key KEY                     Start the MCP server for Claude Code
-    npx mnemos-capture setup-hooks --key KEY                   Install inbox count hook (fast)
-    npx mnemos-capture setup-hooks --key KEY --briefing        Install full briefing hook (uses LLM)
-    npx mnemos-capture setup-hooks --key KEY --vault           Install vault hook (PreToolCall)
-    npx mnemos-capture setup-hooks --key KEY --briefing --vault  Install both hooks
-    npx mnemos-capture config set agent "claude -p"            Set which AI assistant kos drives
-    npx mnemos-capture kos --key KEY [--plan FILE]             Implement a plan in an isolated worktree
-    npx mnemos-capture help                                    Show this help
+    xmu                                                        Open Xmu in your browser
+    xmu serve-mcp --key KEY                                    Start the MCP server for your AI worker
+    xmu setup-hooks --key KEY                                  Install inbox count hook (fast)
+    xmu setup-hooks --key KEY --briefing                       Install full briefing hook (uses LLM)
+    xmu setup-hooks --key KEY --vault                          Install vault hook (PreToolCall)
+    xmu setup-hooks --key KEY --briefing --vault               Install both hooks
+    xmu config set agent "claude -p"                           Set which AI worker kos drives
+    xmu kos --key KEY [--plan FILE]                            Implement a plan in an isolated worktree
+    xmu help                                                   Show this help
 
-  MCP tools (via your AI assistant):
+    npx -y mnemos-capture@latest …                             Same CLI, via the published package
+
+  MCP tools (via your AI worker):
     briefing          — Session-start briefing with ranked insights to apply
     generate_plan     — Turn selected captures into a full implementation plan
     list_plans        — List or read saved implementation plans
     vault_scan        — Scan all captures for relevance to current activity
     curate            — Validate URLs and flag stale captures
 
-  kos — implement plans with your own AI assistant (model-agnostic):
-    1. Tell Mnemos which assistant to drive (once):
-         mnemos config set agent "claude -p"      # or "codex exec", "aider --yes --message"
+  kos — implement plans with your own AI worker (model-agnostic):
+    1. Tell Xmu which assistant to drive (once):
+         xmu config set agent "claude -p"      # or "codex exec", "aider --yes --message"
     2. Generate a plan via the generate_plan MCP tool.
-    3. Run: mnemos kos --key YOUR_KEY
+    3. Run: xmu kos --key YOUR_KEY
        kos creates an isolated git worktree, hands the plan to your assistant,
        and reports the branch + the plan's Verification Checklist when done.
 
@@ -112,7 +114,7 @@ function printHelp() {
     4. Start capturing!
 
   Connect to Claude Code:
-    claude mcp add mnemos -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
+    claude mcp add xmu -- npx -y mnemos-capture@latest serve-mcp --key YOUR_API_KEY
 
   The @latest tag ensures every Claude Code session uses the most recent
   published version. serve-mcp also self-upgrades on startup as a safety net

package/dist/cli/kos.js

@@ -1,8 +1,8 @@
 /**
- * kos — Mnemos' Knowledge Operations orchestrator.
+ * kos — mnemos' Knowledge Operations orchestrator.
  *
- * Drives whatever AI assistant the user configured (`mnemos config set agent ...`)
- * to implement a generated plan in an isolated git worktree. Mnemos owns the
+ * Drives whatever AI assistant the user configured (`xmu config set agent ...`)
+ * to implement a generated plan in an isolated git worktree. mnemos owns the
  * harness-independent parts: fetching the plan, the worktree, and reporting the
  * Verification Checklist. The assistant is a black box — model-agnostic by design.
  */
@@ -54,10 +54,10 @@ function run(cmd, cwd) {
 export async function kos(apiKey, opts = {}) {
     const cfg = readConfig();
     if (!cfg.agent) {
-        console.error("No agent configured. Tell Mnemos which AI assistant to drive:\n");
-        console.error('  mnemos config set agent "claude -p"               # Claude Code');
-        console.error('  mnemos config set agent "codex exec"              # Codex');
-        console.error('  mnemos config set agent "aider --yes --message"   # Aider');
+        console.error("No agent configured. Tell Xmu which AI worker to drive:\n");
+        console.error('  xmu config set agent "claude -p"               # Claude Code');
+        console.error('  xmu config set agent "codex exec"              # Codex');
+        console.error('  xmu config set agent "aider --yes --message"   # Aider');
         process.exit(1);
     }
     // 1. Resolve the plan — explicit filename, or the newest saved plan
@@ -77,7 +77,7 @@ export async function kos(apiKey, opts = {}) {
         repoRoot = run("git rev-parse --show-toplevel");
     }
     catch {
-        console.error("mnemos kos must be run inside a git repository.");
+        console.error("xmu kos must be run inside a git repository.");
         process.exit(1);
         return;
     }

package/dist/cli/mcp-server.js

@@ -1,13 +1,20 @@
-// MCP server that runs locally via stdio and proxies to the hosted Mnemos API.
-// 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";
+// MCP server that runs locally via stdio and proxies to the hosted mnemos API.
+// Used by Claude Code: claude mcp add xmu -- npx mnemos-capture serve-mcp --key <api-key>
+const DEFAULT_HOSTED_URL = "https://mnemos-capture.vercel.app/api/mcp";
+/** Override for pointing the proxy at a local instance during development. */
+const HOSTED_URL = process.env.XMU_API_URL ?? process.env.MNEMOS_API_URL ?? DEFAULT_HOSTED_URL;
 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`);
+}
+/** In-flight proxied requests, so shutdown can wait for them. */
+const pending = new Set();
+function rpcError(id, message) {
+    sendMessage({ jsonrpc: "2.0", id, error: { code: -32603, message } });
 }
 async function proxyToHosted(apiKey, msg) {
+    let res;
     try {
-        const res = await fetch(HOSTED_URL, {
+        res = await fetch(HOSTED_URL, {
             method: "POST",
             headers: {
                 "Content-Type": "application/json",
@@ -15,17 +22,50 @@ async function proxyToHosted(apiKey, msg) {
             },
             body: JSON.stringify(msg),
         });
-        const data = (await res.json());
-        sendMessage(data);
     }
     catch (err) {
-        sendMessage({
-            jsonrpc: "2.0",
-            id: msg.id,
-            error: { code: -32603, message: err instanceof Error ? err.message : "Proxy error" },
-        });
+        const detail = err instanceof Error ? err.message : "unknown error";
+        rpcError(msg.id, `Could not reach Xmu at ${HOSTED_URL}: ${detail}`);
+        return;
+    }
+    const body = await res.text().catch(() => "");
+    const result = interpretResponse(res.status, res.headers.get("content-type"), body);
+    if ("error" in result) {
+        rpcError(msg.id, result.error);
+        return;
+    }
+    sendMessage(result.data);
+}
+/**
+ * Turn a raw HTTP reply into either parsed JSON-RPC data or a useful message.
+ *
+ * Parsing straight to JSON turns any non-JSON reply — an HTML error page from a
+ * 500, a proxy block page, a login redirect — into "Unexpected token '<'",
+ * which says nothing about what actually happened. Reporting the status and a
+ * snippet makes the real cause visible in the MCP client.
+ *
+ * Exported for testing; this is the logic worth covering, not the stdio plumbing.
+ */
+export function interpretResponse(status, contentType, body) {
+    const type = contentType ?? "";
+    if (!type.includes("application/json")) {
+        const snippet = body.trim().slice(0, 200).replace(/\s+/g, " ");
+        return {
+            error: `Xmu returned a non-JSON response (HTTP ${status}${type ? `, ${type}` : ""})${snippet ? `: ${snippet}` : ""}`,
+        };
+    }
+    try {
+        return { data: JSON.parse(body) };
+    }
+    catch {
+        return { error: `Xmu returned malformed JSON (HTTP ${status}).` };
     }
 }
+/** Track a proxied request so shutdown can await it. */
+function track(p) {
+    pending.add(p);
+    void p.finally(() => pending.delete(p));
+}
 export async function serveMcp() {
     // Parse --key flag
     const args = process.argv.slice(2);
@@ -57,38 +97,33 @@ export async function serveMcp() {
     catch {
         // Non-fatal — hook setup should never block the MCP server from starting
     }
-    process.stderr.write("Mnemos MCP server starting (proxying to hosted instance)...\n");
+    process.stderr.write("Xmu MCP server starting (proxying to hosted instance)...\n");
     let buffer = "";
     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);
+                track(proxyToHosted(apiKey, msg));
             }
             catch {
-                process.stderr.write(`Failed to parse: ${body}\n`);
+                process.stderr.write(`Failed to parse: ${line}\n`);
             }
         }
     });
-    process.stdin.on("end", () => process.exit(0));
+    // Wait for in-flight requests before exiting: exiting immediately on stdin
+    // close discards responses that were still being fetched, so the client sees
+    // silence rather than an answer or an error.
+    process.stdin.on("end", () => {
+        void Promise.allSettled([...pending]).then(() => process.exit(0));
+    });
 }

package/dist/cli/version-check.js

@@ -59,7 +59,7 @@ export async function maybeSelfUpgrade() {
     const latest = await getLatestVersion();
     if (!latest || !isNewer(latest, current))
         return false;
-    process.stderr.write(`Mnemos: upgrading to v${latest} (was v${current})...\n`);
+    process.stderr.write(`Xmu: upgrading to v${latest} (was v${current})...\n`);
     const child = spawn("npx", ["-y", `mnemos-capture@${latest}`, ...process.argv.slice(2)], {
         stdio: "inherit",
         env: { ...process.env, MNEMOS_UPGRADED: "1" },

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "mnemos-capture",
-  "version": "1.2.0",
-  "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.",
+  "version": "1.3.0",
+  "description": "Xmu — Turn what you discover into context your AI workers can use. Capture once, then brief, plan, and execute with any MCP-compatible tool.",
   "type": "module",
   "bin": {
-    "mnemos-capture": "./dist/cli/index.js"
+    "mnemos-capture": "./dist/cli/index.js",
+    "xmu": "./dist/cli/index.js"
   },
   "scripts": {
     "dev": "next dev",
@@ -13,10 +14,14 @@
     "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",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit"
   },
   "keywords": [
     "ai",
+    "xmu",
     "knowledge",
     "capture",
     "claude",
@@ -40,23 +45,26 @@
     "README.md"
   ],
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.36.3",
+    "@anthropic-ai/sdk": "^0.122.0",
     "@vercel/postgres": "^0.10.0",
     "next": "^16.1.6",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20",
-    "@types/react": "^19",
-    "@types/react-dom": "^19",
+    "@playwright/test": "^1.62.1",
+    "@types/node": "^26",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.5",
     "autoprefixer": "^10.4.21",
+    "eslint": "^9.39.5",
+    "eslint-config-next": "^16.3.3",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
-    "typescript": "^5",
+    "typescript": "^6.0.3",
     "vitest": "^4.1.8"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20.9"
   }
 }

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/);
-    });
-});