@memly/mcp-server 0.1.1 → 0.2.0

package/README.md

@@ -56,7 +56,19 @@ Go to [memly.site/dashboard/api-keys](https://memly.site/dashboard/api-keys)
 }
 ```
 
-## Available Tools
+### Automatic Context (Zero Friction) ⚡
+
+To make your AI agent proactively load context at the start of every session, add this to your `.cursorrules`, `.windsurfrules`, or `GEMINI.md`:
+
+```markdown
+# Memly Integration
+At the start of every session, you MUST:
+1. Call `memly.search_memories({ query: "current active task", limit: 5 })`
+2. Use this context to understand the project state.
+3. When you make major decisions, call `memly.save_memory`.
+```
+
+### Tools
 
 | Tool | Description |
 |---|---|

package/dist/index.js

@@ -19968,7 +19968,48 @@ class MemlyClient {
 
 // src/tools.ts
 function registerTools(server, client) {
-  server.tool("search_memories", "Search your stored code memories semantically. Returns relevant memories based on meaning, not just keywords.", {
+  server.tool("load_context", [
+    "ALWAYS call this tool FIRST, before responding to any message in a new conversation.",
+    "It loads your persistent memory from previous sessions so you can provide accurate, context-aware assistance.",
+    "Do not skip this — without it you are missing critical context about the user's project, decisions, and preferences."
+  ].join(" "), {
+    topic: exports_external.string().optional().describe('Optional: topic or question to focus the memory search (e.g. "authentication", "database schema"). Leave empty to load general recent context.')
+  }, async ({ topic }) => {
+    try {
+      const query = topic ?? "recent technical decisions architecture patterns current work";
+      const result = await client.searchMemories(query, undefined, 10);
+      if (result.is_cold_start || result.memories.length === 0) {
+        return {
+          content: [{
+            type: "text",
+            text: "\uD83E\uDDE0 Memly: No memories yet for this project. I'll start learning from this session — important decisions and context will be saved automatically."
+          }]
+        };
+      }
+      const formatted = result.memories.map((m, i) => `[${i + 1}] ${m.chunk_type ?? "general"} | confidence: ${m.confidence ? (m.confidence * 100).toFixed(0) + "%" : "n/a"}
+${m.content}`).join(`
+
+`);
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83E\uDDE0 Memly: Loaded ${result.memories.length} memories from previous sessions.
+
+${formatted}
+
+Use this context to inform your responses.`
+        }]
+      };
+    } catch (err) {
+      return {
+        content: [{
+          type: "text",
+          text: `\uD83E\uDDE0 Memly: Could not load context (${err instanceof Error ? err.message : String(err)}). Continuing without memory.`
+        }]
+      };
+    }
+  });
+  server.tool("search_memories", "Search your stored memories semantically. Call this when you need to recall a specific previous decision, code pattern, or technical context that may not have been loaded by load_context.", {
     query: exports_external.string().min(1).describe("What to search for (natural language)"),
     project_id: exports_external.string().uuid().optional().describe("Limit search to a specific project"),
     limit: exports_external.number().int().min(1).max(20).optional().describe("Max results (default: 5)")
@@ -20003,8 +20044,8 @@ ${formatted}`
       };
     }
   });
-  server.tool("remember", "Store a new memory — a fact, decision, code pattern, or important context you want to recall later.", {
-    content: exports_external.string().min(1).max(1e4).describe("The content to remember"),
+  server.tool("remember", "Save an important fact, decision, or code pattern to persistent memory. Call this proactively whenever: the user makes an architectural decision, reveals important project context, you solve a non-trivial problem, or the user explicitly asks you to remember something.", {
+    content: exports_external.string().min(1).max(1e4).describe("The content to remember — be specific and self-contained so it makes sense out of context"),
     project_id: exports_external.string().uuid().optional().describe("Associate with a specific project")
   }, async ({ content, project_id }) => {
     try {
@@ -20012,7 +20053,7 @@ ${formatted}`
       return {
         content: [{
           type: "text",
-          text: `✅ Memorized! Content queued for processing (${content.length} chars).`
+          text: `✅ Saved to memory (${content.length} chars). This will be available in future sessions.`
         }]
       };
     } catch (err) {
@@ -20025,27 +20066,6 @@ ${formatted}`
       };
     }
   });
-  server.tool("forget", "Delete a specific memory by its ID.", {
-    memory_id: exports_external.string().uuid().describe("The ID of the memory to delete")
-  }, async ({ memory_id }) => {
-    try {
-      await client.deleteMemory(memory_id);
-      return {
-        content: [{
-          type: "text",
-          text: `\uD83D\uDDD1️ Memory ${memory_id} deleted.`
-        }]
-      };
-    } catch (err) {
-      return {
-        content: [{
-          type: "text",
-          text: `Failed to delete: ${err instanceof Error ? err.message : String(err)}`
-        }],
-        isError: true
-      };
-    }
-  });
   server.tool("list_projects", "List all your projects with memory statistics.", {}, async () => {
     try {
       const stats = await client.getStats();
@@ -20139,8 +20159,222 @@ function registerResources(server, client) {
   });
 }
 
+// src/prompts.ts
+function registerPrompts(server, client) {
+  server.prompt("restore_context", {
+    project_id: exports_external.string().uuid().optional().describe("Project ID to load context from")
+  }, async (args) => {
+    const project_id = args?.project_id;
+    const stats = await client.getStats();
+    const project = stats.projects.find((p) => p.project_id === project_id) ?? stats.projects[0];
+    if (!project) {
+      return {
+        messages: [
+          {
+            role: "assistant",
+            content: {
+              type: "text",
+              text: "No memories found. I'm ready to start learning from this session."
+            }
+          }
+        ]
+      };
+    }
+    const result = await client.searchMemories("context restore", project.project_id, 10);
+    const memoryText = result.memories.map((m) => `[MEMORY:${m.id} (${m.created_at})]
+${m.content}`).join(`
+
+`);
+    return {
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Restore context for project ${project.project_id}`
+          }
+        },
+        {
+          role: "assistant",
+          content: {
+            type: "text",
+            text: `I've retrieved the following context from Memly:
+
+${memoryText}
+
+I am ready to continue our work.`
+          }
+        }
+      ]
+    };
+  });
+}
+
+// src/init.ts
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { homedir, platform } from "node:os";
+var MEMLY_INSTRUCTION_BLOCK = `
+## Memly — Persistent Memory (Auto-Enabled)
+
+You have access to the Memly MCP server (\`memly\`).
+
+**RULES (always follow, no exceptions):**
+
+1. **At the start of EVERY conversation**, call \`load_context\` before answering anything.
+   - This loads memories from previous sessions.
+   - If the user's message gives a clear topic, pass it as \`topic\` (e.g., \`topic: "authentication"\`).
+   - Otherwise call with no arguments.
+
+2. **During the conversation**, call \`remember\` proactively whenever:
+   - The user makes an architectural or technical decision
+   - You solve a non-trivial bug or problem
+   - The user shares important project context, preferences, or constraints
+   - The user explicitly says "remember this"
+
+3. **Never** ask the user if you should remember something — just do it silently.
+`.trim();
+function writeCopilotInstructions(projectRoot) {
+  const githubDir = join(projectRoot, ".github");
+  const filePath = join(githubDir, "copilot-instructions.md");
+  if (!existsSync(githubDir))
+    mkdirSync(githubDir, { recursive: true });
+  const MARKER = "<!-- memly-instructions -->";
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf-8");
+    if (existing.includes(MARKER)) {
+      return { ide: "VS Code / GitHub Copilot", file: filePath, status: "skipped" };
+    }
+    writeFileSync(filePath, `${existing.trimEnd()}
+
+${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+${MARKER}
+`);
+    return { ide: "VS Code / GitHub Copilot", file: filePath, status: "updated" };
+  }
+  writeFileSync(filePath, `${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+${MARKER}
+`);
+  return { ide: "VS Code / GitHub Copilot", file: filePath, status: "created" };
+}
+function writeCursorRules(projectRoot) {
+  const filePath = join(projectRoot, ".cursorrules");
+  const MARKER = "# memly-instructions";
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf-8");
+    if (existing.includes(MARKER)) {
+      return { ide: "Cursor", file: filePath, status: "skipped" };
+    }
+    writeFileSync(filePath, `${existing.trimEnd()}
+
+${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+    return { ide: "Cursor", file: filePath, status: "updated" };
+  }
+  writeFileSync(filePath, `${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+  return { ide: "Cursor", file: filePath, status: "created" };
+}
+function writeWindsurfRules(projectRoot) {
+  const filePath = join(projectRoot, ".windsurfrules");
+  const MARKER = "# memly-instructions";
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf-8");
+    if (existing.includes(MARKER)) {
+      return { ide: "Windsurf", file: filePath, status: "skipped" };
+    }
+    writeFileSync(filePath, `${existing.trimEnd()}
+
+${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+    return { ide: "Windsurf", file: filePath, status: "updated" };
+  }
+  writeFileSync(filePath, `${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+  return { ide: "Windsurf", file: filePath, status: "created" };
+}
+function writeClaudeDesktop() {
+  const os = platform();
+  let configPath;
+  if (os === "darwin") {
+    configPath = join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  } else if (os === "win32") {
+    configPath = join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+  } else {
+    configPath = join(homedir(), ".config", "Claude", "claude_desktop_config.json");
+  }
+  if (!existsSync(configPath))
+    return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config2 = JSON.parse(raw);
+    const servers = config2["mcpServers"];
+    if (!servers?.["memly"])
+      return null;
+    if (servers["memly"]["systemPrompt"]) {
+      return { ide: "Claude Desktop", file: configPath, status: "skipped" };
+    }
+    servers["memly"]["systemPrompt"] = MEMLY_INSTRUCTION_BLOCK;
+    writeFileSync(configPath, JSON.stringify(config2, null, 2));
+    return { ide: "Claude Desktop", file: configPath, status: "updated" };
+  } catch {
+    return null;
+  }
+}
+function runInit() {
+  const projectRoot = resolve(process.cwd());
+  const results = [];
+  console.log(`
+\uD83E\uDDE0 Memly Init — setting up auto-context for your IDEs
+`);
+  console.log(`   Project root: ${projectRoot}
+`);
+  results.push(writeCopilotInstructions(projectRoot));
+  const hasCursor = existsSync(join(projectRoot, ".cursor")) || existsSync(join(projectRoot, ".cursorrules")) || existsSync(join(homedir(), ".cursor"));
+  if (hasCursor) {
+    results.push(writeCursorRules(projectRoot));
+  }
+  const hasWindsurf = existsSync(join(projectRoot, ".windsurfrules")) || existsSync(join(homedir(), ".codeium"));
+  if (hasWindsurf) {
+    results.push(writeWindsurfRules(projectRoot));
+  }
+  const claudeResult = writeClaudeDesktop();
+  if (claudeResult)
+    results.push(claudeResult);
+  const icons = {
+    created: "✅",
+    updated: "✅",
+    skipped: "⏭️ "
+  };
+  for (const r of results) {
+    const rel = r.file.replace(projectRoot, ".").replace(homedir(), "~");
+    console.log(`  ${icons[r.status]} ${r.ide} — ${r.status}: ${rel}`);
+  }
+  if (results.length === 0) {
+    console.log("  ℹ️  No supported IDEs detected automatically.");
+    console.log(`     Add the following to your IDE's instruction file manually:
+`);
+    console.log(MEMLY_INSTRUCTION_BLOCK);
+  }
+  console.log(`
+✅ Done! Memly will now load context automatically at the start of every conversation.
+`);
+  console.log(`   Tip: run this again after adding a new IDE to your workflow.
+`);
+}
+
 // src/index.ts
 var apiKey = process.env.MEMLY_API_KEY;
+if (process.argv.includes("--init")) {
+  runInit();
+  process.exit(0);
+}
 if (!apiKey) {
   console.error("❌ MEMLY_API_KEY environment variable is required.");
   console.error("   Get your key at https://memly.site/dashboard/api-keys");
@@ -20162,6 +20396,7 @@ if (isHttp) {
         const server = new McpServer({ name: "memly", version: "0.1.0" });
         registerTools(server, client);
         registerResources(server, client);
+        registerPrompts(server, client);
         const transport = new WebStandardStreamableHTTPServerTransport({
           sessionIdGenerator: undefined
         });
@@ -20178,6 +20413,7 @@ if (isHttp) {
   const server = new McpServer({ name: "memly", version: "0.1.0" });
   registerTools(server, client);
   registerResources(server, client);
+  registerPrompts(server, client);
   const transport = new StdioServerTransport;
   await server.connect(transport);
   console.error("\uD83E\uDDE0 Memly MCP Server (stdio) connected");

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@memly/mcp-server",
-    "version": "0.1.1",
+    "version": "0.2.0",
     "description": "Memly MCP Server — persistent memory for any IDE",
     "type": "module",
     "main": "dist/index.js",
     "bin": {
-        "memly-mcp": "dist/index.js"
+        "memly-mcp": "dist/index.js",
+        "memly": "dist/index.js"
     },
     "files": [
         "dist",