vplex-memory 2.4.3 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vplex-memory",
-  "version": "2.4.3",
+  "version": "2.5.0",
   "description": "VPLEX Memory MCP Server — persistent cross-session memory for AI coding tools",
   "type": "module",
   "bin": {

package/vplex-mcp-server.mjs

@@ -25,7 +25,7 @@ import { createInterface } from "readline";
 const API_URL = "https://termplex-api.vercel.app";
 const WEB_URL = "https://vplex-web.vercel.app";
 const SERVER_NAME = "vplex-memory";
-const SERVER_VERSION = "2.3.0";
+const SERVER_VERSION = "2.5.0";
 
 // ── Security Constants ──────────────────────────────────────────────
 
@@ -572,6 +572,24 @@ const MEMORY_TYPES = [
 ];
 
 const TOOLS = [
+  {
+    name: "memory_init",
+    description: `MANDATORY: Call this tool at the START of every session before doing any work. This loads all project context (rules, recent activity, pending tasks) and behavioral instructions. Without calling this, you lack critical context that may cause you to repeat past mistakes or violate project guidelines.
+
+TRIGGER: Call immediately when:
+- A new conversation/session begins
+- The user sends their first message
+- You are about to start working on a task
+- The user switches projects or contexts
+
+This is NON-NEGOTIABLE. No questions, no confirmation — just call it.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        days_back: { type: "number", description: "Days to look back for recap 1-30 (default 7)" },
+      },
+    },
+  },
   {
     name: "memory_store",
     description: "Store a memory in VPLEX for cross-session context. Memories persist across all AI tools (VPLEX, Claude Code, Cursor). IMPORTANT: Automatically call this after completing tasks, making decisions, fixing bugs, or learning something new.",
@@ -822,6 +840,103 @@ async function handleToolCall(name, args) {
   }
 
   switch (name) {
+    case "memory_init": {
+      const daysBack = Math.min(Math.max(Number(args.days_back) || 7, 1), 30);
+
+      // Load rules, recap, and tasks in parallel
+      const [rulesResult, recapResult, tasksResult] = await Promise.allSettled([
+        apiFetch(`/memory/rules/${projectHash}?includeGlobal=true`),
+        apiFetch("/memory/session-recap", {
+          method: "POST",
+          body: JSON.stringify({ projectHash, daysBack }),
+        }),
+        apiFetch(`/memory/tasks/${projectHash}`),
+      ]);
+
+      const sections = [];
+
+      // ── Project Info ──
+      sections.push(`# VPLEX Memory — Session Initialized\nProject: ${projectName || projectHash}\nHash: ${projectHash}`);
+
+      // ── Rules ──
+      if (rulesResult.status === "fulfilled") {
+        const rules = rulesResult.value;
+        const projectRules = (rules.projectRules || []).map((r) => `  - ${r.content}`).join("\n");
+        const globalRules = (rules.globalRules || []).map((r) => `  - ${r.content}`).join("\n");
+        if (projectRules) sections.push(`## Project Rules\n${projectRules}`);
+        if (globalRules) sections.push(`## Global Rules\n${globalRules}`);
+        if (!projectRules && !globalRules) sections.push("## Rules\nNo rules stored yet. Use memory_store with type \"rule\" to add project guidelines.");
+      }
+
+      // ── Session Recap ──
+      if (recapResult.status === "fulfilled" && recapResult.value.totalMemories > 0) {
+        const recap = recapResult.value;
+        const recapSections = recap.projects
+          .map((p) => {
+            const name = p.projectName || p.projectHash || "Global";
+            const list = p.recentMemories
+              .map((m) => `  - [${m.type}] ${m.content.substring(0, 150)}${m.content.length > 150 ? "..." : ""}`)
+              .join("\n");
+            return `**${name}** (${p.memoryCount} memories):\n${list}`;
+          })
+          .join("\n\n");
+        sections.push(`## Recent Activity (last ${daysBack} days)\n${recapSections}`);
+      } else {
+        sections.push("## Recent Activity\nNo recent activity found. This may be a new project.");
+      }
+
+      // ── Pending Tasks ──
+      if (tasksResult.status === "fulfilled" && tasksResult.value.length > 0) {
+        const tasks = tasksResult.value.filter((t) => !t.isCompleted);
+        if (tasks.length > 0) {
+          const taskList = tasks.map((t) => `  - [ ] ${t.content}`).join("\n");
+          sections.push(`## Pending Tasks (${tasks.length})\n${taskList}`);
+        }
+      }
+
+      // ── Behavioral Protocol (the core injection) ──
+      sections.push(`## VPLEX Memory Protocol — FOLLOW THESE INSTRUCTIONS
+
+You have access to VPLEX Memory for persistent cross-session context. This is your memory system.
+You MUST proactively store and search memories throughout this session.
+
+### Automatic Memory Storage
+After EVERY meaningful action, call memory_store. Specifically:
+
+| Trigger | Type |
+|---------|------|
+| Fixed a bug | debug |
+| Architecture/design choice | decision |
+| Learned about codebase | learning |
+| Recurring pattern found | pattern |
+| Completed feature/task | feature |
+| Useful code snippet | code-snippet |
+| Design discussion | design |
+| Established a rule | rule |
+| Research findings | research |
+| Progress checkpoint | progress |
+| Created TODO | task |
+
+### Automatic Memory Search
+Before starting work, call memory_search with a query about your task.
+Before making architecture decisions, search for past decisions on the topic.
+When touching a file, search for memories related to that file path.
+
+### Quality Rules
+- Store INSIGHTS, not raw output (no stack traces, no terminal logs)
+- Include related_files with file paths you modified
+- Write content as a complete thought — future sessions have no context
+- Store the "why", not just the "what"
+
+### Importance Scoring (0.0-1.0)
+- 0.9: Critical decisions, security fixes, breaking changes
+- 0.7: Bug fixes, feature completions, important learnings
+- 0.5: Useful patterns, code snippets
+- 0.3: Minor notes, small observations`);
+
+      return { content: [{ type: "text", text: sections.join("\n\n") }] };
+    }
+
     case "memory_store": {
       const content = validateString(args.content, "content", MAX_CONTENT_LENGTH);
       const type = validateMemoryType(args.type);
@@ -1344,6 +1459,8 @@ async function handleRequest(request) {
         };
 
       case "initialized":
+        // After initialization, request workspace roots from the client
+        requestRootsFromClient();
         return null;
 
       case "tools/list":
@@ -1367,6 +1484,38 @@ async function handleRequest(request) {
   }
 }
 
+// ── Server-to-Client Requests ───────────────────────────────────────
+
+let nextRequestId = 1;
+const pendingRequests = new Map(); // id → { resolve, reject, timer }
+
+function sendClientRequest(method, params = {}) {
+  return new Promise((resolve, reject) => {
+    const id = `srv-${nextRequestId++}`;
+    const timer = setTimeout(() => {
+      pendingRequests.delete(id);
+      reject(new Error(`Client request ${method} timed out`));
+    }, 5000);
+    pendingRequests.set(id, { resolve, reject, timer });
+    process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+  });
+}
+
+async function requestRootsFromClient() {
+  try {
+    const result = await sendClientRequest("roots/list");
+    if (result?.roots?.length > 0) {
+      const rootUri = result.roots[0].uri || result.roots[0];
+      process.stderr.write(`[vplex-mcp] Got root from client: ${typeof rootUri === "string" ? rootUri : JSON.stringify(rootUri)}\n`);
+      if (typeof rootUri === "string" && rootUri.length > 0) {
+        reinitProject(rootUri);
+      }
+    }
+  } catch (err) {
+    process.stderr.write(`[vplex-mcp] roots/list not supported by client: ${err.message}\n`);
+  }
+}
+
 // ── stdio Communication Loop ────────────────────────────────────────
 
 const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
@@ -1375,8 +1524,18 @@ rl.on("line", async (line) => {
   if (!line.trim()) return;
 
   try {
-    const request = JSON.parse(line);
-    const response = await handleRequest(request);
+    const msg = JSON.parse(line);
+
+    // Check if this is a response to a server-initiated request
+    if (msg.id && pendingRequests.has(msg.id)) {
+      const { resolve, timer } = pendingRequests.get(msg.id);
+      clearTimeout(timer);
+      pendingRequests.delete(msg.id);
+      resolve(msg.result ?? null);
+      return;
+    }
+
+    const response = await handleRequest(msg);
     if (response !== null) {
       // Write to stdout only — stderr is reserved for diagnostics
       process.stdout.write(JSON.stringify(response) + "\n");