@echomem/mcp 1.4.1 → 1.4.3

package/dist/index.js

@@ -4,13 +4,15 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from "@modelcontextprotocol/sdk/types.js";
 import axios from "axios";
 import { ZodError } from "zod";
-import { canonicalToolNames, deleteMemorySchema, keywordsSchema, listToolSpecs, othersSchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, timeRangeSchema, } from "./v1-contract.js";
+import { canonicalToolNames, deleteMemorySchema, getByContextSchema, keywordsSchema, listToolSpecs, othersSchema, resolveCanonicalToolName, saveConversationSchema, searchMemoriesSchema, timeRangeSchema, } from "./v1-contract.js";
 import { KeyStore } from "./keystore.js";
 import { EventLogger, hashText } from "./events.js";
 import { buildReportText } from "./report.js";
+import { contextHealthMarkdown, recomposeCapsuleMarkdown } from "./hud/api.js";
 import { createHash, randomUUID } from "node:crypto";
 import { fetchEncryptionConfig, decryptMemoryFields } from "./encryption.js";
 import { runCli } from "./setup.js";
+import { MCP_PACKAGE_VERSION, MCP_SERVER_INSTRUCTIONS } from "./package-metadata.js";
 const ECHO_API_BASE_URL = process.env.ECHO_API_BASE_URL || "https://echo-mem-chrome.vercel.app";
 const MEMORY_FEED_API_URL = process.env.MEMORY_FEED_API_URL || "https://memory-feed.vercel.app";
 /** Thrown when no API token is present yet — the model gets a "run login" nudge, not a hard error. */
@@ -690,6 +692,7 @@ class EchoMemApiClient {
             title: parsed.title,
             // Stable per-session id so multiple saves in this coding session group under one context.
             conversationKey: this.sessionId,
+            passthrough: parsed.passthrough || false,
             triggerMessage: parsed.triggerMessage ||
                 lastUserMessageFromMessages(parsed.messages) ||
                 lastUserMessageFromConversationText(parsed.conversation),
@@ -751,6 +754,15 @@ class EchoMemApiClient {
         });
         return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
     }
+    async getMemoriesByContext(args) {
+        const parsed = getByContextSchema.parse(args);
+        const enc = await this.encState();
+        const response = await this.axios.post("/api/extension/memories/by-context", {
+            contextId: parsed.contextId,
+            limit: parsed.limit,
+        });
+        return enc.enabled ? await this.decryptResult(response.data, enc.key) : response.data;
+    }
     async searchMemoriesByKeywords(args) {
         const parsed = keywordsSchema.parse(args);
         const enc = await this.encState();
@@ -778,7 +790,7 @@ class EchoMemApiClient {
         }
     }
 }
-const SERVER_VERSION = "1.1.0";
+const SERVER_VERSION = MCP_PACKAGE_VERSION;
 class EchoMemMCPServer {
     server;
     client;
@@ -793,6 +805,7 @@ class EchoMemMCPServer {
             name: "echomem-mcp",
             version: SERVER_VERSION,
         }, {
+            instructions: MCP_SERVER_INSTRUCTIONS,
             capabilities: {
                 tools: {},
             },
@@ -870,6 +883,45 @@ class EchoMemMCPServer {
                 if (canonicalName === canonicalToolNames.report) {
                     return { content: [{ type: "text", text: await buildReportText(false) }] };
                 }
+                if (canonicalName === canonicalToolNames.contextHealth) {
+                    const client = isRecord(request.params.arguments) && typeof request.params.arguments.client === "string"
+                        ? request.params.arguments.client
+                        : "auto";
+                    const mode = client === "codex" || client === "claude-code" || client === "claude-desktop" || client === "auto"
+                        ? client
+                        : "auto";
+                    return { content: [{ type: "text", text: await contextHealthMarkdown(mode) }] };
+                }
+                if (canonicalName === canonicalToolNames.recompose) {
+                    const client = isRecord(request.params.arguments) && typeof request.params.arguments.client === "string"
+                        ? request.params.arguments.client
+                        : "auto";
+                    const mode = client === "codex" || client === "claude-code" || client === "claude-desktop" || client === "auto"
+                        ? client
+                        : "auto";
+                    const capsuleText = await recomposeCapsuleMarkdown(mode);
+                    // If logged in, persist the capsule via passthrough so it's retrievable by contextId.
+                    if (this.client.hasToken()) {
+                        try {
+                            const saveResult = await this.client.saveConversation({
+                                conversation: capsuleText,
+                                title: "Session capsule (recompose)",
+                                source: "mcp_recompose",
+                                passthrough: true,
+                            });
+                            const ctxId = saveResult?.contextId;
+                            const capId = saveResult?.capsuleId;
+                            const persistLine = ctxId
+                                ? `\n\n---\nCapsule persisted${capId ? ` (${capId})` : ""}. To reload in a fresh session:\nget_memories_by_context({ contextId: "${ctxId}" })`
+                                : "";
+                            return { content: [{ type: "text", text: capsuleText + persistLine }] };
+                        }
+                        catch {
+                            // Persistence is best-effort; return the capsule text regardless.
+                        }
+                    }
+                    return { content: [{ type: "text", text: capsuleText }] };
+                }
                 if (!this.client.hasToken())
                     throw new NoTokenError();
                 if (canonicalName !== canonicalToolNames.save) {
@@ -886,6 +938,8 @@ class EchoMemMCPServer {
                         return await this.handleSave(request.params.arguments, rec);
                     case canonicalToolNames.timeRange:
                         return await this.handleTimeRange(request.params.arguments);
+                    case canonicalToolNames.getByContext:
+                        return await this.handleGetByContext(request.params.arguments);
                     case canonicalToolNames.keywords:
                         return await this.handleKeywords(request.params.arguments);
                     case canonicalToolNames.others:
@@ -940,6 +994,8 @@ class EchoMemMCPServer {
                 rec.latency_ms = Date.now() - t0;
                 this.events.record(rec);
                 if (canonicalName !== canonicalToolNames.report &&
+                    canonicalName !== canonicalToolNames.contextHealth &&
+                    canonicalName !== canonicalToolNames.recompose &&
                     canonicalName !== canonicalToolNames.save &&
                     this.client.hasToken()) {
                     const finalAnalytics = {
@@ -1061,14 +1117,46 @@ Details: ${m.details || "N/A"}`)
             rec.conversation_chars = text.length;
             rec.save_source = typeof a?.source === "string" ? a.source : sourceFallback;
         }
-        const { success, memoriesExtracted, error } = await this.client.saveConversation(enrichedArgs);
+        const { success, memoriesExtracted, extractedMemories, contextId, capsuleId, passthrough: isPassthrough, error } = await this.client.saveConversation(enrichedArgs);
         if (!success)
             throw new Error(`EchoMem API Error: ${error}`);
         if (rec)
             rec.memories_extracted = typeof memoriesExtracted === "number" ? memoriesExtracted : undefined;
-        return {
-            content: [{ type: "text", text: `Successfully ingested conversation. Extracted ${memoriesExtracted} memory distinct events.` }],
-        };
+        // Passthrough saves store the capsule verbatim — no extraction, no embeddings.
+        if (isPassthrough) {
+            const text = [
+                `Session capsule saved (passthrough, no extraction).`,
+                typeof capsuleId === "string" && capsuleId ? `Capsule ID: ${capsuleId}` : "",
+                typeof contextId === "string" && contextId ? `Context: ${contextId}` : "",
+                "",
+                `To reload this capsule in a fresh session: get_memories_by_context({ contextId: "${contextId}" })`,
+            ].filter(Boolean).join("\n");
+            return { content: [{ type: "text", text }] };
+        }
+        // Surface WHAT was captured (not just the count) so the agent can verify the key facts survived
+        // extraction, and so it holds the ids to deterministically re-fetch this batch later (warm-up).
+        const saved = Array.isArray(extractedMemories) ? extractedMemories.filter(isRecord) : [];
+        const list = saved
+            .map((m, idx) => {
+            const keys = readString(m, "keys") ?? "(no key)";
+            const description = readString(m, "description") ?? "";
+            const details = readString(m, "details") ?? "";
+            const id = readString(m, "id");
+            return [
+                `[${idx + 1}] ${keys}${id ? ` · id ${id}` : ""}`,
+                description ? `Description: ${description}` : "",
+                details ? `Details: ${details}` : "",
+            ].filter(Boolean).join("\n");
+        })
+            .join("\n\n");
+        const text = [
+            `Successfully ingested conversation. Extracted ${memoriesExtracted} memory distinct events.`,
+            list,
+            saved.length
+                ? `Verify these captured the key facts. To re-fetch this exact batch later, search by the ids above${typeof contextId === "string" && contextId ? ` (context ${contextId})` : ""}.`
+                : "",
+        ].filter(Boolean).join("\n\n");
+        return { content: [{ type: "text", text }] };
     }
     async handleTimeRange(args) {
         const parsed = timeRangeSchema.parse(args);
@@ -1095,6 +1183,31 @@ Details: ${m.details || "N/A"}`)
             ],
         };
     }
+    async handleGetByContext(args) {
+        const parsed = getByContextSchema.parse(args);
+        const { success, memories, error } = await this.client.getMemoriesByContext(args);
+        if (!success)
+            throw new Error(`EchoMem API Error: ${error}`);
+        if (!memories?.length) {
+            return {
+                content: [{ type: "text", text: `No memories found for context ${parsed.contextId}.` }],
+            };
+        }
+        const formattedResults = memories
+            .map((m, idx) => `[${idx + 1}] ${m.keys || "Saved memory"}${m.id ? ` · id ${m.id}` : ""}
+Time: ${m.time} | Category: ${m.category} | Object: ${m.object} | Emotion: ${m.emotion}
+Description: ${m.description}
+Details: ${m.details || "N/A"}`)
+            .join("\n\n");
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Recalled ${memories.length} memories from context ${parsed.contextId} (deterministic full batch):\n\n${formattedResults}`,
+                },
+            ],
+        };
+    }
     async handleKeywords(args) {
         const parsed = keywordsSchema.parse(args);
         const { success, memories, error } = await this.client.searchMemoriesByKeywords(args);

package/dist/package-metadata.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+const FALLBACK_PACKAGE = {
+    name: "@echomem/mcp",
+    version: "0.0.0",
+    description: "EchoMem Cloud-First MCP Server",
+};
+function loadPackageJson() {
+    try {
+        const packageUrl = new URL("../package.json", import.meta.url);
+        return JSON.parse(fs.readFileSync(packageUrl, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+const packageJson = loadPackageJson();
+function stringOrFallback(value, fallback) {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+export const MCP_PACKAGE_NAME = stringOrFallback(packageJson.name, FALLBACK_PACKAGE.name);
+export const MCP_PACKAGE_VERSION = stringOrFallback(packageJson.version, FALLBACK_PACKAGE.version);
+export const MCP_PACKAGE_DESCRIPTION = stringOrFallback(packageJson.description, FALLBACK_PACKAGE.description);
+export const MCP_PACKAGE_LABEL = `${MCP_PACKAGE_NAME}@${MCP_PACKAGE_VERSION}`;
+export const MCP_UPDATE_COMMAND = `npx -y ${MCP_PACKAGE_NAME}@latest update`;
+export const MCP_SERVER_INSTRUCTIONS = [
+    `${MCP_PACKAGE_DESCRIPTION} (${MCP_PACKAGE_LABEL}).`,
+    `If the user or local config expects a newer EchoMem MCP version than ${MCP_PACKAGE_VERSION}, update once with \`${MCP_UPDATE_COMMAND}\` and start a new MCP session.`,
+    "Do not auto-update on every MCP startup; this bridge is intentionally stable between explicit updates.",
+].join(" ");
+export function withMcpVersion(description) {
+    return `${description}\n\nEchoMem MCP bridge: ${MCP_PACKAGE_LABEL}. If this version is stale, update once with \`${MCP_UPDATE_COMMAND}\` (add \`--client cursor|windsurf|claude-desktop|codex\` when needed), then start a new MCP session. Do not run updates repeatedly or on every startup.`;
+}

package/dist/report.js

@@ -623,7 +623,7 @@ function renderText(a, memCount, useColor) {
         L(c.green(`✓ You're connected — every new session now builds on your ${memCount} memories.`));
     }
     else {
-        L(c.green("→ Start now (no signup wall):  ") + c.bold("npx -y @echomem/mcp setup"));
+        L(c.green("→ Start now (no signup wall):  ") + c.bold("npm i -g @echomem/mcp@latest && echomem-mcp setup"));
         L(c.dim(`  ~1 minute. Your next coding session recalls instead of re-reading.`));
     }
     NL();