memoryai-mcp 2.2.0 → 2.3.1

package/dist/claude-setup.d.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * memoryai-claude-setup
+ *
+ * Wires MemoryAI into Claude Code at the MECHANISM level using HTTP hooks.
+ * Claude Code injects a hook's `additionalContext` straight into the model's
+ * context — no agent decision required — so memory works the moment it's set up,
+ * exactly like the OpenAI proxy. The user runs this once and never thinks about
+ * memory again:
+ *
+ *   - SessionStart    → POST /v1/hooks/claude/session-start  (inject DNA + recent context)
+ *   - UserPromptSubmit→ POST /v1/hooks/claude/user-prompt     (recall before answering)
+ *   - Stop            → POST /v1/hooks/claude/stop            (auto-store after each turn)
+ *
+ * It also registers the MCP server (so the 70+ tools are available for advanced
+ * use) and writes a CLAUDE.md note. Existing settings/CLAUDE.md are merged, never
+ * clobbered.
+ */
+export {};

package/dist/claude-setup.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+/**
+ * memoryai-claude-setup
+ *
+ * Wires MemoryAI into Claude Code at the MECHANISM level using HTTP hooks.
+ * Claude Code injects a hook's `additionalContext` straight into the model's
+ * context — no agent decision required — so memory works the moment it's set up,
+ * exactly like the OpenAI proxy. The user runs this once and never thinks about
+ * memory again:
+ *
+ *   - SessionStart    → POST /v1/hooks/claude/session-start  (inject DNA + recent context)
+ *   - UserPromptSubmit→ POST /v1/hooks/claude/user-prompt     (recall before answering)
+ *   - Stop            → POST /v1/hooks/claude/stop            (auto-store after each turn)
+ *
+ * It also registers the MCP server (so the 70+ tools are available for advanced
+ * use) and writes a CLAUDE.md note. Existing settings/CLAUDE.md are merged, never
+ * clobbered.
+ */
+import { createInterface } from "node:readline";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+function ask(question, fallback) {
+    const suffix = fallback ? ` [${fallback}]` : "";
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            resolve(answer.trim() || fallback || "");
+        });
+    });
+}
+function readJsonSafe(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return JSON.parse(readFileSync(path, "utf-8")) || {};
+    }
+    catch {
+        console.error(`  warn  ${path} is not valid JSON — leaving it untouched and aborting.`);
+        process.exit(1);
+    }
+}
+function writeJson(path, data) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+/** A single HTTP hook handler bound to a MemoryAI endpoint. */
+function httpHook(endpoint, apiKey, timeout) {
+    return {
+        type: "http",
+        url: endpoint,
+        timeout,
+        headers: { Authorization: `Bearer ${apiKey}` },
+        // Required for Claude Code to interpolate the env-style header value.
+        allowedEnvVars: [],
+    };
+}
+/** True if any handler in a hook group already points at a memoryai endpoint. */
+function groupHasMemoryAI(group) {
+    const handlers = (group && group.hooks) || [];
+    return handlers.some((h) => typeof h?.url === "string" && h.url.includes("/v1/hooks/claude/"));
+}
+function ensureHook(settings, event, handler) {
+    settings.hooks = settings.hooks || {};
+    settings.hooks[event] = settings.hooks[event] || [];
+    // De-dupe: skip if a MemoryAI hook for this event already exists.
+    if (settings.hooks[event].some(groupHasMemoryAI))
+        return false;
+    settings.hooks[event].push({ hooks: [handler] });
+    return true;
+}
+const CLAUDE_MD = `
+# MemoryAI — Persistent Memory (automatic)
+
+MemoryAI is wired into this Claude Code via HTTP hooks, so memory works
+automatically at the mechanism level — you don't have to call tools by hand:
+
+- Relevant past context is injected before each prompt (UserPromptSubmit hook).
+- Session-start context (preferences, decisions, recent work) loads on open.
+- Decisions and preferences are stored automatically when each turn ends.
+
+The MemoryAI MCP server is also connected for advanced use. You may call
+\`memory_recall\` explicitly when you need deeper history, but for everyday work
+the hooks handle it. Never store secrets or credentials.
+`;
+const MCP_BLOCK = (apiKey, endpoint) => ({
+    command: "npx",
+    args: ["-y", "memoryai-mcp"],
+    env: { HM_API_KEY: apiKey, HM_ENDPOINT: endpoint },
+});
+/**
+ * Auto-provision a fresh API key from the public self-service endpoint so the
+ * user truly does nothing — no curl, no dashboard. Returns the key string, or
+ * null on any failure (caller falls back to asking). The endpoint is public and
+ * IP-rate-limited server-side; we accept ToS on the user's behalf since running
+ * this installer is an explicit action.
+ */
+async function provisionKey(endpoint, name) {
+    const base = endpoint.replace(/\/+$/, "");
+    try {
+        const resp = await fetch(`${base}/v1/admin/provision`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name: name || "claude-code", tos_accepted: true }),
+        });
+        if (!resp.ok) {
+            const txt = await resp.text().catch(() => "");
+            console.error(`  warn  auto-provision failed (HTTP ${resp.status}). ${txt.slice(0, 200)}`);
+            return null;
+        }
+        const data = (await resp.json());
+        if (data?.api_key) {
+            console.log(`  ok    provisioned new API key (${String(data.api_key).slice(0, 10)}…, plan=${data.plan || "?"})`);
+            return data.api_key;
+        }
+        return null;
+    }
+    catch (e) {
+        console.error(`  warn  auto-provision request error: ${e instanceof Error ? e.message : String(e)}`);
+        return null;
+    }
+}
+async function main() {
+    console.log(`\nMemoryAI — Claude Code Setup (mechanism-level auto-memory)\n`);
+    // Non-interactive fast path: if everything is supplied via env, skip prompts.
+    // MEMORYAI_SCOPE = "user" (default) or "project". Enables CI / scripted installs.
+    const envKey = process.env.HM_API_KEY || process.env.MEMORYAI_API_KEY || "";
+    const envEndpoint = process.env.HM_ENDPOINT || process.env.MEMORYAI_ENDPOINT || "";
+    const envScope = (process.env.MEMORYAI_SCOPE || "").toLowerCase();
+    const nonInteractive = process.env.MEMORYAI_NONINTERACTIVE === "1" || (Boolean(envKey) && Boolean(envEndpoint));
+    let apiKey;
+    let endpoint;
+    let scopeAns;
+    if (nonInteractive) {
+        endpoint = envEndpoint || "https://memoryai.dev";
+        scopeAns = envScope || "u";
+        apiKey = envKey;
+        if (!apiKey) {
+            console.log("  ...  non-interactive, no key — provisioning one");
+            const provisioned = await provisionKey(endpoint, "claude-code");
+            if (provisioned)
+                apiKey = provisioned;
+        }
+        else {
+            console.log("  (non-interactive: using environment configuration)");
+        }
+    }
+    else {
+        endpoint = await ask("Endpoint", envEndpoint || "https://memoryai.dev");
+        apiKey = envKey || (await ask("MemoryAI API key (blank = auto-provision a free one)")).trim();
+        if (!apiKey) {
+            console.log("  ...  no key given — provisioning one for you");
+            const provisioned = await provisionKey(endpoint, "claude-code");
+            if (provisioned)
+                apiKey = provisioned;
+        }
+        scopeAns = (await ask("Apply to (u)ser globally or this (p)roject?", "u")).toLowerCase();
+    }
+    if (!apiKey) {
+        console.error("Error: could not obtain an API key (auto-provision failed). Set HM_API_KEY and re-run.");
+        process.exit(1);
+    }
+    const settingsPath = scopeAns.startsWith("p")
+        ? join(process.cwd(), ".claude", "settings.json")
+        : join(homedir(), ".claude", "settings.json");
+    console.log("");
+    const settings = readJsonSafe(settingsPath);
+    // 1. MCP server (advanced tools)
+    settings.mcpServers = settings.mcpServers || {};
+    if (!settings.mcpServers.memoryai) {
+        settings.mcpServers.memoryai = MCP_BLOCK(apiKey, endpoint);
+        console.log("  add   mcpServers.memoryai");
+    }
+    else {
+        console.log("  skip  mcpServers.memoryai (already present)");
+    }
+    // 2. The three lifecycle hooks. UserPromptSubmit gets a tighter timeout
+    //    because it blocks the prompt until it returns.
+    const base = endpoint.replace(/\/+$/, "");
+    const added = {
+        SessionStart: ensureHook(settings, "SessionStart", httpHook(`${base}/v1/hooks/claude/session-start`, apiKey, 10)),
+        UserPromptSubmit: ensureHook(settings, "UserPromptSubmit", httpHook(`${base}/v1/hooks/claude/user-prompt`, apiKey, 10)),
+        Stop: ensureHook(settings, "Stop", httpHook(`${base}/v1/hooks/claude/stop`, apiKey, 15)),
+    };
+    for (const [event, didAdd] of Object.entries(added)) {
+        console.log(`  ${didAdd ? "add  " : "skip "} hooks.${event}${didAdd ? "" : " (already present)"}`);
+    }
+    writeJson(settingsPath, settings);
+    console.log(`  write ${settingsPath}`);
+    // 3. CLAUDE.md note (append if missing).
+    const claudeMdPath = scopeAns.startsWith("p")
+        ? join(process.cwd(), "CLAUDE.md")
+        : join(homedir(), ".claude", "CLAUDE.md");
+    const existing = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, "utf-8") : "";
+    if (!existing.includes("MemoryAI — Persistent Memory")) {
+        writeFileSync(claudeMdPath, existing + (existing ? "\n" : "") + CLAUDE_MD, "utf-8");
+        console.log(`  ${existing ? "append" : "create"} ${claudeMdPath}`);
+    }
+    else {
+        console.log(`  skip  ${claudeMdPath} (note already present)`);
+    }
+    console.log(`
+Done. MemoryAI runs automatically in Claude Code — nothing else to do.
+  - Context is recalled before each prompt and injected for you.
+  - Decisions/preferences are stored when each turn ends.
+
+Next steps:
+  1. Restart Claude Code (loads the hooks + MCP server).
+  2. Just work normally. Memory persists across sessions on its own.
+`);
+    rl.close();
+}
+main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});