@contextstream/mcp-server 0.4.49 → 0.4.51

package/dist/hooks/on-save-intent.js

@@ -0,0 +1,132 @@
+#!/usr/bin/env node
+
+// src/hooks/on-save-intent.ts
+var ENABLED = process.env.CONTEXTSTREAM_SAVE_INTENT_ENABLED !== "false";
+var SAVE_PATTERNS = [
+  // Direct save requests
+  /\b(save|store|record|capture|log|document|write down|note down|keep track)\b.*\b(this|that|it|the)\b/i,
+  /\b(save|store|record|capture|log)\b.*\b(to|in|for)\b.*\b(contextstream|memory|later|reference|future)\b/i,
+  // Document creation
+  /\b(create|make|write|draft)\b.*\b(a|the)\b.*\b(document|doc|note|summary|report|spec|design)\b/i,
+  /\b(document|summarize|write up)\b.*\b(this|that|the|our)\b.*\b(decision|discussion|conversation|meeting|finding)\b/i,
+  // Memory/reference requests
+  /\b(remember|don't forget|keep in mind|note that|important to remember)\b/i,
+  /\bfor\s+(future|later)\s+reference\b/i,
+  /\b(add|put)\s+(this|it|that)\s+(to|in)\s+(memory|notes|docs)\b/i,
+  // Decision tracking
+  /\b(we\s+)?(decided|agreed|concluded|determined)\b.*\b(to|that)\b/i,
+  /\blet('s|s)\s+document\b/i,
+  /\bsave\s+(this|the)\s+(decision|choice|approach)\b/i,
+  // Implementation/design docs
+  /\b(implementation|design|architecture|spec)\s+(doc|document|plan)\b/i,
+  /\bwrite\s+(the|a|an)\s+.*(md|markdown|readme)\b/i
+];
+var LOCAL_FILE_PATTERNS = [
+  /\b(save|write|create)\s+(it|this|the\s+\w+)\s+(to|in|as)\s+[./~]/i,
+  /\b(save|write)\s+to\s+.*(\.md|\.txt|\.json|docs\/|notes\/)/i,
+  /\bcreate\s+(a|the)\s+file\b/i
+];
+function detectsSaveIntent(text) {
+  const hasSaveIntent = SAVE_PATTERNS.some((p) => p.test(text));
+  const isLocalFile = LOCAL_FILE_PATTERNS.some((p) => p.test(text));
+  return { hasSaveIntent, isLocalFile };
+}
+var SAVE_GUIDANCE = `[CONTEXTSTREAM DOCUMENT STORAGE]
+The user wants to save/store content. Use ContextStream instead of local files:
+
+**For decisions/notes:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture",
+  event_type="decision|note|insight",
+  title="...",
+  content="...",
+  importance="high|medium|low"
+)
+\`\`\`
+
+**For documents/specs:**
+\`\`\`
+mcp__contextstream__docs(
+  action="create",
+  title="...",
+  content="...",
+  doc_type="implementation|design|spec|guide"
+)
+\`\`\`
+
+**For plans:**
+\`\`\`
+mcp__contextstream__session(
+  action="capture_plan",
+  title="...",
+  steps=[...]
+)
+\`\`\`
+
+**Why ContextStream?**
+- Persists across sessions (local files don't)
+- Searchable and retrievable
+- Shows up in context automatically
+- Can be shared with team
+
+Only save to local files if user explicitly requests a specific file path.
+[END GUIDANCE]`;
+async function runOnSaveIntentHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  let prompt = input.prompt || "";
+  if (!prompt && input.session?.messages) {
+    for (const msg of [...input.session.messages].reverse()) {
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          prompt = msg.content;
+        } else if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+              prompt = block.text;
+              break;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  if (!prompt) {
+    process.exit(0);
+  }
+  const { hasSaveIntent, isLocalFile } = detectsSaveIntent(prompt);
+  if (hasSaveIntent || isLocalFile) {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: SAVE_GUIDANCE
+        }
+      })
+    );
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-save-intent") || process.argv[2] === "on-save-intent";
+if (isDirectRun) {
+  runOnSaveIntentHook().catch(() => process.exit(0));
+}
+export {
+  runOnSaveIntentHook
+};

package/dist/hooks/on-task.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+// src/hooks/on-task.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_TASK_HOOK_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureTaskInvocation(description, prompt, agentType, result, sessionId) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "task_agent",
+    title: `Agent: ${agentType} - ${description}`,
+    content: JSON.stringify({
+      description,
+      prompt: prompt.slice(0, 1e3),
+      agent_type: agentType,
+      result: result.slice(0, 2e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["task", "agent", agentType.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnTaskHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  if (input.tool_name !== "Task") {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const description = input.tool_input?.description || "Unknown task";
+  const prompt = input.tool_input?.prompt || "";
+  const agentType = input.tool_input?.subagent_type || "general-purpose";
+  const result = input.tool_result?.output || "";
+  const sessionId = input.session_id || "unknown";
+  captureTaskInvocation(description, prompt, agentType, result, sessionId).catch(() => {
+  });
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-task") || process.argv[2] === "on-task";
+if (isDirectRun) {
+  runOnTaskHook().catch(() => process.exit(0));
+}
+export {
+  runOnTaskHook
+};

package/dist/hooks/on-web.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+
+// src/hooks/on-web.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_WEB_HOOK_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function captureWebResearch(toolName, target, summary, sessionId) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "web_research",
+    title: `${toolName}: ${target.slice(0, 60)}`,
+    content: JSON.stringify({
+      tool: toolName,
+      target,
+      summary: summary.slice(0, 1e3),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "medium",
+    tags: ["research", "web", toolName.toLowerCase()],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e3);
+    await fetch(`${API_URL}/api/v1/memory/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": API_KEY
+      },
+      body: JSON.stringify(payload),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+  } catch {
+  }
+}
+async function runOnWebHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const toolName = input.tool_name || "";
+  if (!["WebFetch", "WebSearch"].includes(toolName)) {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "unknown";
+  let target = "";
+  let summary = "";
+  switch (toolName) {
+    case "WebFetch":
+      target = input.tool_input?.url || "";
+      const prompt = input.tool_input?.prompt || "fetched content";
+      const content = input.tool_result?.output || input.tool_result?.content || "";
+      summary = `Fetched ${target} (${prompt}): ${content.slice(0, 300)}`;
+      break;
+    case "WebSearch":
+      target = input.tool_input?.query || "";
+      const results = input.tool_result?.results || [];
+      const topResults = results.slice(0, 3).map((r) => `- ${r.title}: ${r.url}`).join("\n");
+      summary = `Search: "${target}"
+Top results:
+${topResults}`;
+      break;
+  }
+  if (target) {
+    captureWebResearch(toolName, target, summary, sessionId).catch(() => {
+    });
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-web") || process.argv[2] === "on-web";
+if (isDirectRun) {
+  runOnWebHook().catch(() => process.exit(0));
+}
+export {
+  runOnWebHook
+};

package/dist/hooks/post-compact.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+// src/hooks/post-compact.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_POSTCOMPACT_ENABLED !== "false";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var WORKSPACE_ID = null;
+function loadConfigFromMcpJson(cwd) {
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 5; i++) {
+    if (!API_KEY) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const content = fs.readFileSync(mcpPath, "utf-8");
+          const config = JSON.parse(content);
+          const csEnv = config.mcpServers?.contextstream?.env;
+          if (csEnv?.CONTEXTSTREAM_API_KEY) {
+            API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+          }
+          if (csEnv?.CONTEXTSTREAM_API_URL) {
+            API_URL = csEnv.CONTEXTSTREAM_API_URL;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID) {
+      const csConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(csConfigPath)) {
+        try {
+          const content = fs.readFileSync(csConfigPath, "utf-8");
+          const csConfig = JSON.parse(content);
+          if (csConfig.workspace_id) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!API_KEY) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const content = fs.readFileSync(homeMcpPath, "utf-8");
+        const config = JSON.parse(content);
+        const csEnv = config.mcpServers?.contextstream?.env;
+        if (csEnv?.CONTEXTSTREAM_API_KEY) {
+          API_KEY = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          API_URL = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function fetchLastTranscript(sessionId) {
+  if (!API_KEY) {
+    return null;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const url = new URL(`${API_URL}/api/v1/transcripts`);
+    url.searchParams.set("session_id", sessionId);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("sort", "created_at:desc");
+    if (WORKSPACE_ID) {
+      url.searchParams.set("workspace_id", WORKSPACE_ID);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      const data = await response.json();
+      if (data.transcripts && data.transcripts.length > 0) {
+        return data.transcripts[0];
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatTranscriptSummary(transcript) {
+  const messages = transcript.messages || [];
+  const activeFiles = transcript.metadata?.active_files || [];
+  const toolCallCount = transcript.metadata?.tool_call_count || 0;
+  const userMessages = messages.filter((m) => m.role === "user").slice(-3).map((m) => `- "${m.content.slice(0, 100)}${m.content.length > 100 ? "..." : ""}"`).join("\n");
+  const lastAssistant = messages.filter((m) => m.role === "assistant" && !m.content.startsWith("[Tool:")).slice(-1)[0];
+  const lastWork = lastAssistant ? lastAssistant.content.slice(0, 300) + (lastAssistant.content.length > 300 ? "..." : "") : "None recorded";
+  return `## Pre-Compaction State Restored
+
+### Active Files (${activeFiles.length})
+${activeFiles.slice(0, 10).map((f) => `- ${f}`).join("\n") || "None tracked"}
+
+### Recent User Requests
+${userMessages || "None recorded"}
+
+### Last Work in Progress
+${lastWork}
+
+### Session Stats
+- Tool calls: ${toolCallCount}
+- Messages: ${messages.length}
+- Saved at: ${transcript.created_at}`;
+}
+async function runPostCompactHook() {
+  if (!ENABLED) {
+    process.exit(0);
+  }
+  let inputData = "";
+  for await (const chunk of process.stdin) {
+    inputData += chunk;
+  }
+  if (!inputData.trim()) {
+    process.exit(0);
+  }
+  let input;
+  try {
+    input = JSON.parse(inputData);
+  } catch {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "";
+  let restoredContext = "";
+  if (sessionId && API_KEY) {
+    const transcript = await fetchLastTranscript(sessionId);
+    if (transcript) {
+      restoredContext = formatTranscriptSummary(transcript);
+    }
+  }
+  const context = `[POST-COMPACTION - Context Restored]
+
+${restoredContext || "No saved state found. Starting fresh."}
+
+**IMPORTANT:** Call \`mcp__contextstream__context(user_message="resuming after compaction")\` to get full context and any pending tasks.
+
+The conversation was compacted to save memory. The above summary was automatically restored from ContextStream.`;
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PostCompact",
+        additionalContext: context
+      }
+    })
+  );
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("post-compact") || process.argv[2] === "post-compact";
+if (isDirectRun) {
+  runPostCompactHook().catch(() => process.exit(0));
+}
+export {
+  runPostCompactHook
+};