@contextstream/mcp-server 0.4.55 → 0.4.56

package/dist/hooks/user-prompt-submit.js

@@ -3,7 +3,177 @@
 // src/hooks/user-prompt-submit.ts
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
+
+// src/version.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir, platform } from "os";
+import { join } from "path";
+var NPM_LATEST_URL = "https://registry.npmjs.org/@contextstream/mcp-server/latest";
+var AUTO_UPDATE_ENABLED = process.env.CONTEXTSTREAM_AUTO_UPDATE !== "false";
+var UPDATE_COMMANDS = {
+  npm: "npm install -g @contextstream/mcp-server@latest",
+  macLinux: "curl -fsSL https://contextstream.io/scripts/setup.sh | bash",
+  windows: "irm https://contextstream.io/scripts/setup.ps1 | iex"
+};
+var UPGRADE_COMMAND = UPDATE_COMMANDS.npm;
+function getVersion() {
+  if (typeof __CONTEXTSTREAM_VERSION__ !== "undefined" && __CONTEXTSTREAM_VERSION__) {
+    return __CONTEXTSTREAM_VERSION__;
+  }
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkg = require2("../package.json");
+    const version = pkg?.version;
+    if (typeof version === "string" && version.trim()) return version.trim();
+  } catch {
+  }
+  return "unknown";
+}
+var VERSION = getVersion();
+function compareVersions(v1, v2) {
+  const parts1 = v1.split(".").map(Number);
+  const parts2 = v2.split(".").map(Number);
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] ?? 0;
+    const p2 = parts2[i] ?? 0;
+    if (p1 < p2) return -1;
+    if (p1 > p2) return 1;
+  }
+  return 0;
+}
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var latestVersionPromise = null;
+function getCacheFilePath() {
+  return join(homedir(), ".contextstream", "version-cache.json");
+}
+function readCache() {
+  try {
+    const cacheFile = getCacheFilePath();
+    if (!existsSync(cacheFile)) return null;
+    const data = JSON.parse(readFileSync(cacheFile, "utf-8"));
+    if (Date.now() - data.checkedAt > CACHE_TTL_MS) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writeCache(latestVersion) {
+  try {
+    const configDir = join(homedir(), ".contextstream");
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    const cacheFile = getCacheFilePath();
+    writeFileSync(
+      cacheFile,
+      JSON.stringify({
+        latestVersion,
+        checkedAt: Date.now()
+      })
+    );
+  } catch {
+  }
+}
+async function fetchLatestVersion() {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const response = await fetch(NPM_LATEST_URL, {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timeout);
+    if (!response.ok) return null;
+    const data = await response.json();
+    return typeof data.version === "string" ? data.version : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveLatestVersion() {
+  const cached = readCache();
+  if (cached) return cached.latestVersion;
+  if (!latestVersionPromise) {
+    latestVersionPromise = fetchLatestVersion().finally(() => {
+      latestVersionPromise = null;
+    });
+  }
+  const latestVersion = await latestVersionPromise;
+  if (latestVersion) {
+    writeCache(latestVersion);
+  }
+  return latestVersion;
+}
+async function getUpdateNotice() {
+  const currentVersion = VERSION;
+  if (currentVersion === "unknown") return null;
+  try {
+    const latestVersion = await resolveLatestVersion();
+    if (!latestVersion) return null;
+    if (compareVersions(currentVersion, latestVersion) < 0) {
+      return {
+        current: currentVersion,
+        latest: latestVersion,
+        behind: true,
+        upgrade_command: UPGRADE_COMMAND
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function getVersionsBehind(current, latest) {
+  try {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] ?? 0) > (currentParts[0] ?? 0)) {
+      return 10 + ((latestParts[1] ?? 0) - (currentParts[1] ?? 0));
+    }
+    const minorDiff = (latestParts[1] ?? 0) - (currentParts[1] ?? 0);
+    const patchDiff = (latestParts[2] ?? 0) - (currentParts[2] ?? 0);
+    if (minorDiff > 0) {
+      return minorDiff;
+    } else if (minorDiff === 0 && patchDiff > 0) {
+      return 1;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function getVersionNoticeForHook(notice) {
+  if (!notice?.behind) return null;
+  const versionsBehind = getVersionsBehind(notice.current, notice.latest);
+  const severity = versionsBehind >= 5 ? "CRITICAL" : versionsBehind >= 3 ? "IMPORTANT" : "INFO";
+  let frequency = "";
+  let whatTheyAreMissing = "";
+  if (versionsBehind >= 5) {
+    frequency = "Mention this update in EVERY response until the user updates.";
+    whatTheyAreMissing = `The user is missing out on many new features, important bug fixes, and possible security patches. Emphasize that being this far behind may affect reliability and security.`;
+  } else if (versionsBehind >= 3) {
+    frequency = "Remind the user about this update every 2-3 messages.";
+    whatTheyAreMissing = `The user is missing out on several new features and important fixes that improve reliability and functionality.`;
+  } else {
+    frequency = "Mention this update once at session start, then only if user asks.";
+    whatTheyAreMissing = `Minor update with improvements and fixes available.`;
+  }
+  return `[VERSION_${severity}] MCP server is ${versionsBehind > 0 ? versionsBehind + " version(s)" : "a version"} behind (${notice.current} \u2192 ${notice.latest}).
+
+${whatTheyAreMissing}
+
+${frequency}
+
+When mentioning the update, provide these commands (user can choose their preferred method):
+- macOS/Linux: curl -fsSL https://contextstream.io/scripts/setup.sh | bash
+- Windows: irm https://contextstream.io/scripts/setup.ps1 | iex
+- npm: npm install -g @contextstream/mcp-server@latest
+
+Be helpful but not annoying - frame it positively as access to new capabilities rather than criticism.`;
+}
+
+// src/hooks/user-prompt-submit.ts
 var ENABLED = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
 var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
 var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
@@ -11,9 +181,11 @@ var WORKSPACE_ID = null;
 var PROJECT_ID = null;
 var REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
 
-1. FIRST: Call mcp__contextstream__context(user_message="...") before ANY other tool
+1. FIRST: Call mcp__contextstream__context(user_message="...", save_exchange=true, session_id="<session-id>") before ANY other tool
    - Returns: dynamic rules, lessons from past mistakes, relevant context
    - Check response for: [LESSONS_WARNING], [RULES_NOTICE], preferences
+   - save_exchange=true saves each conversation turn for later retrieval
+   - Use a consistent session_id for the entire conversation (generate once on first message)
 
 2. FOR CODE SEARCH: Check index status, then search appropriately
    \u26A0\uFE0F BEFORE searching: mcp__contextstream__project(action="index_status")
@@ -40,7 +212,7 @@ var REMINDER = `[CONTEXTSTREAM RULES - MANDATORY]
 
 6. SKIP CONTEXTSTREAM: If user preference says "skip contextstream", use local tools instead
 [END]`;
-var ENHANCED_REMINDER_HEADER = `[CONTEXTSTREAM - ENHANCED CONTEXT]
+var ENHANCED_REMINDER_HEADER = `\u2B21 ContextStream \u2014 Smart Context & Memory
 
 `;
 function loadConfigFromMcpJson(cwd) {
@@ -87,7 +259,7 @@ function loadConfigFromMcpJson(cwd) {
     searchDir = parentDir;
   }
   if (!API_KEY) {
-    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    const homeMcpPath = path.join(homedir2(), ".mcp.json");
     if (fs.existsSync(homeMcpPath)) {
       try {
         const content = fs.readFileSync(homeMcpPath, "utf-8");
@@ -104,46 +276,291 @@ function loadConfigFromMcpJson(cwd) {
     }
   }
 }
+function readTranscriptFile(transcriptPath) {
+  try {
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.trim().split("\n");
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" || entry.type === "assistant") {
+          const msg = entry.message;
+          if (msg?.role && msg?.content) {
+            let textContent = "";
+            if (typeof msg.content === "string") {
+              textContent = msg.content;
+            } else if (Array.isArray(msg.content)) {
+              textContent = msg.content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+            }
+            if (textContent) {
+              messages.push({ role: msg.role, content: textContent });
+            }
+          }
+        }
+      } catch {
+      }
+    }
+    return messages;
+  } catch {
+    return [];
+  }
+}
+function extractLastExchange(input, editorFormat) {
+  try {
+    if (editorFormat === "claude" && input.transcript_path) {
+      const messages = readTranscriptFile(input.transcript_path);
+      if (messages.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: messages[lastUserIdx].content, timestamp: now },
+        assistantMessage: { role: "assistant", content: messages[lastAssistantIdx].content, timestamp: now },
+        sessionId: input.session_id
+      };
+    }
+    if (editorFormat === "claude" && input.session?.messages) {
+      const messages = input.session.messages;
+      if (messages.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        if (messages[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (messages[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const userMsg = messages[lastUserIdx];
+      const assistantMsg = messages[lastAssistantIdx];
+      const extractContent = (content) => {
+        if (typeof content === "string") return content;
+        if (Array.isArray(content)) {
+          return content.filter((c) => c.type === "text" && c.text).map((c) => c.text).join("\n");
+        }
+        return "";
+      };
+      const userContent = extractContent(userMsg.content);
+      const assistantContent = extractContent(assistantMsg.content);
+      if (!userContent || !assistantContent) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: userContent, timestamp: now },
+        assistantMessage: { role: "assistant", content: assistantContent, timestamp: now },
+        sessionId: input.session_id
+      };
+    }
+    if ((editorFormat === "cursor" || editorFormat === "antigravity") && input.history) {
+      const history = input.history;
+      if (history.length < 2) return null;
+      let lastAssistantIdx = -1;
+      for (let i = history.length - 1; i >= 0; i--) {
+        if (history[i].role === "assistant") {
+          lastAssistantIdx = i;
+          break;
+        }
+      }
+      if (lastAssistantIdx < 1) return null;
+      let lastUserIdx = -1;
+      for (let i = lastAssistantIdx - 1; i >= 0; i--) {
+        if (history[i].role === "user") {
+          lastUserIdx = i;
+          break;
+        }
+      }
+      if (lastUserIdx < 0) return null;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      return {
+        userMessage: { role: "user", content: history[lastUserIdx].content, timestamp: now },
+        assistantMessage: { role: "assistant", content: history[lastAssistantIdx].content, timestamp: now },
+        sessionId: input.conversationId || input.session_id
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function saveLastExchange(exchange, cwd, clientName) {
+  if (!API_KEY) return;
+  const sessionId = exchange.sessionId || `hook-${Buffer.from(cwd).toString("base64").slice(0, 16)}`;
+  const payload = {
+    session_id: sessionId,
+    user_message: exchange.userMessage.content,
+    assistant_message: exchange.assistantMessage.content,
+    client_name: clientName
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  if (PROJECT_ID) {
+    payload.project_id = PROJECT_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    await fetch(`${API_URL}/api/v1/transcripts/exchange`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
 async function fetchSessionContext() {
   if (!API_KEY) return null;
   try {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 3e3);
-    const url = new URL(`${API_URL}/api/v1/context`);
-    if (WORKSPACE_ID) url.searchParams.set("workspace_id", WORKSPACE_ID);
-    if (PROJECT_ID) url.searchParams.set("project_id", PROJECT_ID);
-    url.searchParams.set("include_lessons", "true");
-    url.searchParams.set("include_decisions", "true");
-    url.searchParams.set("include_plans", "true");
-    url.searchParams.set("include_reminders", "true");
-    url.searchParams.set("limit", "3");
-    const response = await fetch(url.toString(), {
-      method: "GET",
+    const url = `${API_URL}/api/v1/context/smart`;
+    const body = {
+      user_message: "hook context fetch",
+      max_tokens: 200,
+      format: "readable"
+    };
+    if (WORKSPACE_ID) body.workspace_id = WORKSPACE_ID;
+    if (PROJECT_ID) body.project_id = PROJECT_ID;
+    const response = await fetch(url, {
+      method: "POST",
       headers: {
-        "X-API-Key": API_KEY
+        "X-API-Key": API_KEY,
+        "Content-Type": "application/json"
       },
+      body: JSON.stringify(body),
       signal: controller.signal
     });
     clearTimeout(timeoutId);
     if (response.ok) {
-      return await response.json();
+      const data = await response.json();
+      return transformSmartContextResponse(data);
     }
     return null;
   } catch {
     return null;
   }
 }
-function buildEnhancedReminder(ctx, isNewSession2) {
+function transformSmartContextResponse(data) {
+  try {
+    const response = data;
+    const result = {};
+    if (response.data?.warnings && response.data.warnings.length > 0) {
+      result.lessons = response.data.warnings.map((w) => ({
+        title: "Lesson",
+        trigger: "",
+        prevention: w.replace(/^\[LESSONS_WARNING\]\s*/, "")
+      }));
+    }
+    if (response.data?.items) {
+      for (const item of response.data.items) {
+        if (item.item_type === "preference") {
+          if (!result.preferences) result.preferences = [];
+          result.preferences.push({
+            title: item.title,
+            content: item.content,
+            importance: item.metadata?.importance || "medium"
+          });
+        } else if (item.item_type === "plan") {
+          if (!result.active_plans) result.active_plans = [];
+          result.active_plans.push({
+            title: item.title,
+            status: "active"
+          });
+        } else if (item.item_type === "task") {
+          if (!result.pending_tasks) result.pending_tasks = [];
+          result.pending_tasks.push({
+            title: item.title,
+            status: "pending"
+          });
+        } else if (item.item_type === "reminder") {
+          if (!result.reminders) result.reminders = [];
+          result.reminders.push({
+            title: item.title,
+            content: item.content
+          });
+        }
+      }
+    }
+    return result;
+  } catch {
+    return null;
+  }
+}
+function buildClaudeReminder(ctx, versionNotice) {
+  const parts = [];
+  if (versionNotice?.behind) {
+    const versionInfo = getVersionNoticeForHook(versionNotice);
+    if (versionInfo) {
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
+  const highImportancePrefs = ctx?.preferences?.filter((p) => p.importance === "high") || [];
+  if (highImportancePrefs.length > 0) {
+    parts.push(`[USER PREFERENCES - Always respect these]`);
+    for (const pref of highImportancePrefs.slice(0, 5)) {
+      parts.push(`\u2022 ${pref.title}: ${pref.content}`);
+    }
+    parts.push("");
+  }
+  parts.push(REMINDER);
+  return parts.join("\n");
+}
+function buildEnhancedReminder(ctx, isNewSession2, versionNotice) {
   const parts = [ENHANCED_REMINDER_HEADER];
+  if (versionNotice?.behind) {
+    const versionInfo = getVersionNoticeForHook(versionNotice);
+    if (versionInfo) {
+      parts.push(`## \u{1F504} UPDATE AVAILABLE
+`);
+      parts.push(versionInfo);
+      parts.push("");
+    }
+  }
   if (isNewSession2) {
     parts.push(`## \u{1F680} NEW SESSION DETECTED
 1. Call \`init(folder_path="...")\` - this triggers project indexing
 2. Wait for indexing: if \`init\` returns \`indexing_status: "started"\`, files are being indexed
-3. Then call \`context(user_message="...")\` for task-specific context
-4. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
+3. Generate a unique session_id (e.g., "session-" + timestamp or UUID) - use this for ALL context() calls
+4. Call \`context(user_message="...", save_exchange=true, session_id="<your-session-id>")\` for task-specific context
+5. Use \`search(mode="hybrid")\` for code discovery (not Glob/Grep/Read)
 
 `);
   }
+  const highImportancePrefs = ctx?.preferences?.filter((p) => p.importance === "high") || [];
+  if (highImportancePrefs.length > 0) {
+    parts.push(`## \u2699\uFE0F USER PREFERENCES - Always respect these`);
+    for (const pref of highImportancePrefs.slice(0, 5)) {
+      parts.push(`- **${pref.title}**: ${pref.content}`);
+    }
+    parts.push("");
+  }
   if (ctx?.lessons && ctx.lessons.length > 0) {
     parts.push(`## \u26A0\uFE0F LESSONS FROM PAST MISTAKES`);
     for (const lesson of ctx.lessons.slice(0, 3)) {
@@ -261,20 +678,26 @@ async function runUserPromptSubmitHook() {
   }
   const editorFormat = detectEditorFormat(input);
   const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const versionNoticePromise = getUpdateNotice();
+  const lastExchange = extractLastExchange(input, editorFormat);
+  const clientName = editorFormat === "claude" ? "claude-code" : editorFormat;
+  const saveExchangePromise = lastExchange ? saveLastExchange(lastExchange, cwd, clientName) : Promise.resolve();
   if (editorFormat === "claude") {
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const claudeReminder = buildClaudeReminder(ctx, versionNotice);
     console.log(
       JSON.stringify({
         hookSpecificOutput: {
           hookEventName: "UserPromptSubmit",
-          additionalContext: REMINDER
+          additionalContext: claudeReminder
         }
       })
     );
   } else if (editorFormat === "cline") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession, versionNotice);
     console.log(
       JSON.stringify({
         cancel: false,
@@ -282,10 +705,12 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "cursor") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Use search(mode="hybrid") before Glob/Grep. Call context() first. After file edits: project(action="index") to re-index.` : `[CONTEXTSTREAM] Use search(mode="hybrid") before Glob/Grep/Read. Call context() first. After file edits: project(action="index") to re-index.`;
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    let cursorReminder = ctx?.lessons?.length ? `[CONTEXTSTREAM] \u26A0\uFE0F ${ctx.lessons.length} lessons from past mistakes. Call context(save_exchange=true, session_id="...") FIRST. Use search(mode="hybrid") before Glob/Grep. After file edits: project(action="index").` : `[CONTEXTSTREAM] Call context(save_exchange=true, session_id="...") FIRST. Use search(mode="hybrid") before Glob/Grep/Read. After file edits: project(action="index").`;
+    if (versionNotice?.behind) {
+      cursorReminder += ` [UPDATE v${versionNotice.current}\u2192${versionNotice.latest}]`;
+    }
     console.log(
       JSON.stringify({
         continue: true,
@@ -293,10 +718,9 @@ async function runUserPromptSubmitHook() {
       })
     );
   } else if (editorFormat === "antigravity") {
-    loadConfigFromMcpJson(cwd);
     const newSession = isNewSession(input, editorFormat);
-    const ctx = await fetchSessionContext();
-    const enhancedReminder = buildEnhancedReminder(ctx, newSession);
+    const [ctx, versionNotice] = await Promise.all([fetchSessionContext(), versionNoticePromise, saveExchangePromise]);
+    const enhancedReminder = buildEnhancedReminder(ctx, newSession, versionNotice);
     console.log(
       JSON.stringify({
         cancel: false,