@memly/mcp-server 0.2.2 → 0.2.4

package/dist/index.js

@@ -20211,130 +20211,286 @@ I am ready to continue our work.`
 }
 
 // src/init.ts
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 var MEMLY_INSTRUCTION_BLOCK = `
-## Memly — Persistent Memory (Auto-Enabled)
+## Memly — Persistent Memory (Auto-Enabled)
 
 You have access to the Memly MCP server (\`memly\`).
 
-**RULES (always follow, no exceptions):**
+**RULES (always follow):**
 
-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.
+1. **At the start of EVERY conversation**, call \`load_context\` before answering.
+   - Pass \`topic\` if the user's message has a clear subject (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
+2. **During the conversation**, call \`remember\` proactively when:
+   - 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"
+   - User shares important project context, preferences, or constraints
+   - User explicitly says "remember this"
 
-3. **Never** ask the user if you should remember something — just do it silently.
+3. **Never** ask if you should remember something — just do it silently.
 `.trim();
+async function validateApiKey(apiKey) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 5000);
+    const response = await fetch("https://api.memly.site/health", {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
 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" };
+  try {
+    if (!existsSync(githubDir)) {
+      mkdirSync(githubDir, { recursive: true });
     }
-    writeFileSync(filePath, `${existing.trimEnd()}
+    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}
+      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" };
+    return { ide: "VS Code / GitHub Copilot", file: filePath, status: "created" };
+  } catch (err) {
+    return {
+      ide: "VS Code / GitHub Copilot",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 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()}
+  try {
+    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}
+      return { ide: "Cursor", file: filePath, status: "updated" };
+    }
+    writeFileSync(filePath, `${MARKER}
 ${MEMLY_INSTRUCTION_BLOCK}
 `);
-  return { ide: "Cursor", file: filePath, status: "created" };
+    return { ide: "Cursor", file: filePath, status: "created" };
+  } catch (err) {
+    return {
+      ide: "Cursor",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 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()}
+  try {
+    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" };
+      return { ide: "Windsurf", file: filePath, status: "updated" };
+    }
+    writeFileSync(filePath, `${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+    return { ide: "Windsurf", file: filePath, status: "created" };
+  } catch (err) {
+    return {
+      ide: "Windsurf",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  writeFileSync(filePath, `${MARKER}
+}
+function writeClineConfig(projectRoot) {
+  const filePath = join(projectRoot, ".clinerules");
+  const MARKER = "# memly-instructions";
+  try {
+    if (existsSync(filePath)) {
+      const existing = readFileSync(filePath, "utf-8");
+      if (existing.includes(MARKER)) {
+        return { ide: "Cline (VS Code)", file: filePath, status: "skipped" };
+      }
+      writeFileSync(filePath, `${existing.trimEnd()}
+
+${MARKER}
+${MEMLY_INSTRUCTION_BLOCK}
+`);
+      return { ide: "Cline (VS Code)", file: filePath, status: "updated" };
+    }
+    writeFileSync(filePath, `${MARKER}
 ${MEMLY_INSTRUCTION_BLOCK}
 `);
-  return { ide: "Windsurf", file: filePath, status: "created" };
+    return { ide: "Cline (VS Code)", file: filePath, status: "created" };
+  } catch (err) {
+    return {
+      ide: "Cline (VS Code)",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function writeContinueConfig() {
+  const configPath = join(homedir(), ".continue", "config.json");
+  if (!existsSync(configPath))
+    return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config2 = JSON.parse(raw);
+    const mcpServers = config2["mcpServers"] ?? {};
+    if (mcpServers["memly"]) {
+      return { ide: "Continue.dev", file: configPath, status: "skipped" };
+    }
+    mcpServers["memly"] = {
+      command: "npx",
+      args: ["-y", "@memly/mcp-server"],
+      env: { MEMLY_API_KEY: process.env.MEMLY_API_KEY ?? "<your-memly-api-key>" }
+    };
+    config2["mcpServers"] = mcpServers;
+    writeFileSync(configPath, JSON.stringify(config2, null, 2));
+    return { ide: "Continue.dev", file: configPath, status: "updated" };
+  } catch (err) {
+    return {
+      ide: "Continue.dev",
+      file: configPath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function writeZedConfig() {
+  const os = platform();
+  const configPath = os === "darwin" ? join(homedir(), "Library", "Application Support", "Zed", "settings.json") : join(homedir(), ".config", "zed", "settings.json");
+  if (!existsSync(configPath))
+    return null;
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const config2 = JSON.parse(raw);
+    const assistant = config2["assistant"] ?? {};
+    const instructions = assistant["instructions"] ?? "";
+    if (instructions.includes("Memly")) {
+      return { ide: "Zed", file: configPath, status: "skipped" };
+    }
+    assistant["instructions"] = instructions ? `${instructions}
+
+${MEMLY_INSTRUCTION_BLOCK}` : MEMLY_INSTRUCTION_BLOCK;
+    config2["assistant"] = assistant;
+    writeFileSync(configPath, JSON.stringify(config2, null, 2));
+    return { ide: "Zed", file: configPath, status: "updated" };
+  } catch (err) {
+    return {
+      ide: "Zed",
+      file: configPath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function writeAiderConfig() {
+  const configPath = join(homedir(), ".aider.conf.yml");
+  if (!existsSync(configPath))
+    return null;
+  try {
+    const existing = readFileSync(configPath, "utf-8");
+    if (existing.includes("memly-instructions")) {
+      return { ide: "Aider (CLI)", file: configPath, status: "skipped" };
+    }
+    const instruction = `
+# memly-instructions
+edit-format: |
+  ${MEMLY_INSTRUCTION_BLOCK.replace(/\n/g, `
+  `)}
+`;
+    writeFileSync(configPath, existing + instruction);
+    return { ide: "Aider (CLI)", file: configPath, status: "updated" };
+  } catch (err) {
+    return {
+      ide: "Aider (CLI)",
+      file: configPath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 function writeJetBrains(projectRoot) {
   const ideaDir = join(projectRoot, ".idea");
   if (!existsSync(ideaDir))
     return null;
   const filePath = join(ideaDir, "mcp.json");
-  const MARKER = '"memly"';
-  if (existsSync(filePath)) {
-    const existing = readFileSync(filePath, "utf-8");
-    if (existing.includes(MARKER)) {
-      return { ide: "JetBrains", file: filePath, status: "skipped" };
-    }
-    try {
+  try {
+    if (existsSync(filePath)) {
+      const existing = readFileSync(filePath, "utf-8");
       const config2 = JSON.parse(existing);
+      if (config2.servers?.["memly"]) {
+        return { ide: "JetBrains", file: filePath, status: "skipped" };
+      }
       config2.servers = config2.servers ?? {};
       config2.servers["memly"] = {
         command: "npx",
         args: ["-y", "@memly/mcp-server"],
-        env: { MEMLY_API_KEY: "<your-memly-api-key>" }
+        env: { MEMLY_API_KEY: process.env.MEMLY_API_KEY ?? "<your-memly-api-key>" }
       };
       writeFileSync(filePath, JSON.stringify(config2, null, 2));
       return { ide: "JetBrains", file: filePath, status: "updated" };
-    } catch {
-      return null;
     }
-  }
-  mkdirSync(ideaDir, { recursive: true });
-  writeFileSync(filePath, JSON.stringify({
-    servers: {
-      memly: {
-        command: "npx",
-        args: ["-y", "@memly/mcp-server"],
-        env: { MEMLY_API_KEY: "<your-memly-api-key>" }
+    mkdirSync(ideaDir, { recursive: true });
+    writeFileSync(filePath, JSON.stringify({
+      servers: {
+        memly: {
+          command: "npx",
+          args: ["-y", "@memly/mcp-server"],
+          env: { MEMLY_API_KEY: process.env.MEMLY_API_KEY ?? "<your-memly-api-key>" }
+        }
       }
-    }
-  }, null, 2));
-  return { ide: "JetBrains", file: filePath, status: "created" };
+    }, null, 2));
+    return { ide: "JetBrains", file: filePath, status: "created" };
+  } catch (err) {
+    return {
+      ide: "JetBrains",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 function writeClaudeDesktop() {
   const os = platform();
@@ -20360,59 +20516,140 @@ function writeClaudeDesktop() {
     servers["memly"]["systemPrompt"] = MEMLY_INSTRUCTION_BLOCK;
     writeFileSync(configPath, JSON.stringify(config2, null, 2));
     return { ide: "Claude Desktop", file: configPath, status: "updated" };
-  } catch {
-    return null;
+  } catch (err) {
+    return {
+      ide: "Claude Desktop",
+      file: configPath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
 }
-function runInit() {
+async function reportTelemetry(results) {
+  try {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), 3000);
+    await fetch("https://api.memly.site/api/telemetry/init", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ides: results.map((r) => r.ide),
+        os: platform(),
+        timestamp: new Date().toISOString()
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+  } catch {}
+}
+async function runInit() {
   const projectRoot = resolve(process.cwd());
-  const results = [];
+  if (projectRoot === homedir()) {
+    console.error("Error: Running in home directory.");
+    console.error(`Run this command inside your project folder.
+`);
+    process.exit(1);
+  }
   console.log(`
-\uD83E\uDDE0 Memly Init — setting up auto-context for your IDEs
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`);
+  console.log("  Memly Init — Auto-Memory Setup");
+  console.log(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+  const apiKey = process.env.MEMLY_API_KEY;
+  if (!apiKey) {
+    console.error(`Error: MEMLY_API_KEY not set.
+`);
+    console.error("Get your API key at: https://memly.site/dashboard");
+    console.error(`Then run: export MEMLY_API_KEY=memly_...
+`);
+    process.exit(1);
+  }
+  process.stdout.write("Validating API key... ");
+  const valid = await validateApiKey(apiKey);
+  if (!valid) {
+    console.error(`✗ Invalid
 `);
-  console.log(`   Project root: ${projectRoot}
+    console.error(`Check your API key at: https://memly.site/dashboard
 `);
+    process.exit(1);
+  }
+  console.log(`✓ Valid
+`);
+  console.log(`Project: ${projectRoot}
+`);
+  console.log(`Detecting IDEs...
+`);
+  const results = [];
   results.push(writeCopilotInstructions(projectRoot));
   const hasCursor = existsSync(join(projectRoot, ".cursor")) || existsSync(join(projectRoot, ".cursorrules")) || existsSync(join(homedir(), ".cursor"));
-  if (hasCursor) {
+  if (hasCursor)
     results.push(writeCursorRules(projectRoot));
-  }
   const hasWindsurf = existsSync(join(projectRoot, ".windsurfrules")) || existsSync(join(homedir(), ".codeium"));
-  if (hasWindsurf) {
+  if (hasWindsurf)
     results.push(writeWindsurfRules(projectRoot));
-  }
+  const clineExtDir = join(homedir(), ".vscode", "extensions");
+  const hasCline = existsSync(join(projectRoot, ".clinerules")) || existsSync(clineExtDir) && readdirSync(clineExtDir).some((d) => d.startsWith("saoudrizwan.claude-dev"));
+  if (hasCline)
+    results.push(writeClineConfig(projectRoot));
+  const continueResult = writeContinueConfig();
+  if (continueResult)
+    results.push(continueResult);
+  const zedResult = writeZedConfig();
+  if (zedResult)
+    results.push(zedResult);
+  const aiderResult = writeAiderConfig();
+  if (aiderResult)
+    results.push(aiderResult);
   const claudeResult = writeClaudeDesktop();
   if (claudeResult)
     results.push(claudeResult);
   const jetbrainsResult = writeJetBrains(projectRoot);
   if (jetbrainsResult)
     results.push(jetbrainsResult);
-  const icons = {
-    created: "✅",
-    updated: "✅",
-    skipped: "⏭️ "
-  };
+  const icons = { created: "✓", updated: "✓", skipped: "⊘", failed: "✗" };
+  console.log(`Results:
+`);
+  console.log("  IDE                          Status    File");
+  console.log("  ──────────────────────────────────────────────────────────────────");
   for (const r of results) {
     const rel = r.file.replace(projectRoot, ".").replace(homedir(), "~");
-    console.log(`  ${icons[r.status]} ${r.ide} — ${r.status}: ${rel}`);
+    const statusLabel = r.status === "failed" ? `failed (${r.error})` : r.status;
+    console.log(`  ${icons[r.status]} ${r.ide.padEnd(28)} ${r.status.padEnd(8)}  ${rel}`);
+    if (r.status === "failed")
+      console.log(`      └─ ${statusLabel}`);
   }
   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(`
+  No supported IDEs detected.`);
+    console.log(`  Add this block manually to your IDE config:
 `);
     console.log(MEMLY_INSTRUCTION_BLOCK);
+    console.log(`
+`);
+    return;
   }
+  try {
+    writeFileSync(join(projectRoot, ".memly-initialized"), new Date().toISOString());
+  } catch {}
+  await reportTelemetry(results);
   console.log(`
-✅ Done! Memly will now load context automatically at the start of every conversation.
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+`);
+  console.log(`Setup complete. Next steps:
+`);
+  console.log("  1. Restart your IDE");
+  console.log("  2. Start a new conversation");
+  console.log(`  3. Memly loads context automatically
 `);
-  console.log(`   Tip: run this again after adding a new IDE to your workflow.
+  console.log("Dashboard: https://memly.site/dashboard");
+  console.log(`Docs:      https://memly.site/docs
 `);
 }
 
 // src/index.ts
 var apiKey = process.env.MEMLY_API_KEY;
 if (process.argv.includes("--init") || process.argv.includes("init")) {
-  runInit();
+  await runInit();
   process.exit(0);
 }
 if (!apiKey) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@memly/mcp-server",
-    "version": "0.2.2",
+    "version": "0.2.4",
     "description": "Memly MCP Server — persistent memory for any IDE",
     "type": "module",
     "main": "dist/index.js",