@memly/mcp-server 0.2.1 → 0.2.3

package/README.md

@@ -1,16 +1,49 @@
 # @memly/mcp-server
 
-> Persistent memory for any IDE that supports MCP.
+> Persistent memory for IDEs that **don't support custom LLM providers**.
 
-## Supported IDEs
+## Proxy vs MCP — which one should I use?
 
-| IDE | Config File |
-|---|---|
-| VS Code + Copilot | `.vscode/mcp.json` |
-| Cursor | Settings → MCP |
-| Claude Desktop | `claude_desktop_config.json` |
-| Windsurf | Settings → MCP |
-| Zed | Settings |
+Memly has two integration modes:
+
+| Mode | How it works | Best for |
+|------|-------------|----------|
+| **Proxy** (transparent) | Point your IDE's base URL to `api.memly.site` — memory injected in 100% of requests, invisible | IDEs that support a custom OpenAI-compatible endpoint |
+| **MCP server** (this package) | Memly runs as an MCP tool — `load_context` is called automatically at session start | IDEs locked to their own AI service |
+
+---
+
+## Which mode for my IDE?
+
+### ✅ Use the Proxy — supports custom endpoint
+
+| IDE / Tool | Where to configure |
+|-----------|-------------------|
+| **Cursor** | Settings → Models → OpenAI Base URL |
+| **Continue.dev** (VS Code / JetBrains extension) | `config.json` → `apiBase` |
+| **Zed** | `settings.json` → `api_url` |
+| **Aider** | `--openai-api-base` CLI flag |
+| **Jan.ai** | Settings → Model → Engine URL |
+| **LM Studio** | Server settings |
+| **Open WebUI** | Admin → Connections |
+| **Msty** | Settings → Custom provider |
+| **Void** | Settings → Custom provider |
+
+### ❌ Use the MCP server — locked provider, no custom endpoint
+
+| IDE / Tool | Reason |
+|-----------|--------|
+| **VS Code + GitHub Copilot** | Microsoft/GitHub auth — base URL not configurable |
+| **JetBrains AI Assistant** | Locked to JetBrains AI Service subscription |
+| **Windsurf (Codeium)** | Cascade uses Codeium's own models — no external endpoint |
+| **Amazon Q / CodeWhisperer** | AWS-only pipeline |
+| **Tabnine** | Proprietary closed service |
+| **Replit AI** | Built into Replit, no external provider |
+| **Gitpod AI** | Locked to their own service |
+| **Sourcegraph Cody** | Locked on free tier |
+| **Claude Desktop** | Chat app, not an IDE — MCP native |
+
+---
 
 ## Quick Start
 
@@ -18,19 +51,25 @@
 
 Go to [memly.site/dashboard/api-keys](https://memly.site/dashboard/api-keys)
 
-### 2. Auto-setup (one command)
+### 2. Configure your IDE's MCP server
 
-Run this in your project root — auto-detects your IDE and writes the instruction file:
+**VS Code / GitHub Copilot** — create `.vscode/mcp.json` in your project:
 
-```bash
-npx @memly/mcp-server init
+```json
+{
+  "servers": {
+    "memly": {
+      "command": "npx",
+      "args": ["-y", "@memly/mcp-server"],
+      "env": {
+        "MEMLY_API_KEY": "memly_your_key_here"
+      }
+    }
+  }
+}
 ```
 
-This creates the right file for your IDE so Memly loads context automatically on every conversation. Run once, forget forever.
-
-### 3. Configure your IDE's MCP server
-
-**VS Code / Copilot** — create `.vscode/mcp.json`:
+**JetBrains** (IntelliJ, WebStorm, PyCharm…) — create `.idea/mcp.json`:
 
 ```json
 {
@@ -46,8 +85,9 @@ This creates the right file for your IDE so Memly loads context automatically on
 }
 ```
 
-**Cursor** — Settings → MCP → Add Server:
-- Command: `npx -y @memly/mcp-server`
+**Windsurf** — Settings → Cascade → MCP Servers → Add:
+- Command: `npx`
+- Args: `-y @memly/mcp-server`
 - Env: `MEMLY_API_KEY=memly_your_key_here`
 
 **Claude Desktop** — edit `claude_desktop_config.json`:
@@ -66,38 +106,42 @@ This creates the right file for your IDE so Memly loads context automatically on
 }
 ```
 
-### Automatic Context (Zero Friction) ⚡
+### 3. Run auto-setup once per project
 
-To make your AI agent proactively load context at the start of every session, add this to your `.cursorrules`, `.windsurfrules`, or `GEMINI.md`:
+Writes the instruction file for your IDE so `load_context` runs automatically at every session start:
 
-```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`.
+```bash
+npx @memly/mcp-server init
 ```
 
-### Tools
+Auto-detects VS Code, Cursor, Windsurf, Claude Desktop. Run once, never think about it again.
+
+---
 
-| Tool | Description |
-|---|---|
-| `search_memories` | Semantic search across your stored memories |
-| `remember` | Store a new memory (fact, decision, pattern) |
-| `forget` | Delete a specific memory by ID |
-| `list_projects` | List all projects with memory stats |
+## Tools
+
+| Tool | When the AI calls it |
+|------|---------------------|
+| `load_context` | **Automatically at session start** — loads memories from previous sessions |
+| `search_memories` | When you ask about something specific not loaded by `load_context` |
+| `remember` | When you make a decision, solve a problem, or say "remember this" |
+| `list_projects` | When you ask to list or switch projects |
+
+---
 
 ## Environment Variables
 
 | Variable | Required | Default | Description |
-|---|---|---|---|
-| `MEMLY_API_KEY` | ✅ | — | Your Memly API key |
-| `MEMLY_API_URL` | — | `https://api.memly.site` | API base URL |
-| `MEMLY_PORT` | — | `3800` | HTTP transport port |
+|----------|----------|---------|-------------|
+| `MEMLY_API_KEY` | ✅ | — | Your Memly API key (`memly_...`) |
+| `MEMLY_API_URL` | — | `https://api.memly.site` | Override for self-hosted deployments |
+| `MEMLY_PORT` | — | `3800` | HTTP transport port (`--http` mode only) |
+
+---
 
-## Self-Hosted (VPS)
+## Self-Hosted
 
-Run alongside your Memly proxy for zero-latency:
+Run alongside your Memly proxy on your VPS for zero-latency:
 
 ```bash
 MEMLY_API_KEY=memly_... bun run packages/mcp-server/src/index.ts --http

package/dist/index.js

@@ -20211,93 +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");
+  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: process.env.MEMLY_API_KEY ?? "<your-memly-api-key>" }
+      };
+      writeFileSync(filePath, JSON.stringify(config2, null, 2));
+      return { ide: "JetBrains", file: filePath, status: "updated" };
+    }
+    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" };
+  } catch (err) {
+    return {
+      ide: "JetBrains",
+      file: filePath,
+      status: "failed",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
 }
 function writeClaudeDesktop() {
   const os = platform();
@@ -20323,56 +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 icons = {
-    created: "✅",
-    updated: "✅",
-    skipped: "⏭️ "
-  };
+  const jetbrainsResult = writeJetBrains(projectRoot);
+  if (jetbrainsResult)
+    results.push(jetbrainsResult);
+  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.1",
+    "version": "0.2.3",
     "description": "Memly MCP Server — persistent memory for any IDE",
     "type": "module",
     "main": "dist/index.js",