@contextstream/mcp-server 0.4.49 → 0.4.51

package/dist/hooks/session-end.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+// src/hooks/session-end.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_SESSION_END_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 {
+      }
+    }
+  }
+}
+function parseTranscriptStats(transcriptPath) {
+  const stats = {
+    messageCount: 0,
+    toolCallCount: 0,
+    duration: 0,
+    filesModified: []
+  };
+  if (!transcriptPath || !fs.existsSync(transcriptPath)) {
+    return stats;
+  }
+  try {
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    let firstTimestamp = null;
+    let lastTimestamp = null;
+    const modifiedFiles = /* @__PURE__ */ new Set();
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" || entry.type === "assistant") {
+          stats.messageCount++;
+        } else if (entry.type === "tool_use") {
+          stats.toolCallCount++;
+          if (["Write", "Edit", "NotebookEdit"].includes(entry.name || "")) {
+            const filePath = entry.input?.file_path;
+            if (filePath) {
+              modifiedFiles.add(filePath);
+            }
+          }
+        }
+        if (entry.timestamp) {
+          const ts = new Date(entry.timestamp);
+          if (!firstTimestamp || ts < firstTimestamp) {
+            firstTimestamp = ts;
+          }
+          if (!lastTimestamp || ts > lastTimestamp) {
+            lastTimestamp = ts;
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+    if (firstTimestamp && lastTimestamp) {
+      stats.duration = Math.round((lastTimestamp.getTime() - firstTimestamp.getTime()) / 1e3);
+    }
+    stats.filesModified = Array.from(modifiedFiles);
+  } catch {
+  }
+  return stats;
+}
+async function finalizeSession(sessionId, stats, reason) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: "session_end",
+    title: `Session Ended: ${reason}`,
+    content: JSON.stringify({
+      session_id: sessionId,
+      reason,
+      stats: {
+        messages: stats.messageCount,
+        tool_calls: stats.toolCallCount,
+        duration_seconds: stats.duration,
+        files_modified: stats.filesModified.length
+      },
+      files_modified: stats.filesModified.slice(0, 20),
+      ended_at: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["session", "end", reason],
+    source_type: "hook",
+    session_id: sessionId
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    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 runSessionEndHook() {
+  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 || "unknown";
+  const transcriptPath = input.transcript_path || "";
+  const reason = input.reason || "user_exit";
+  const stats = parseTranscriptStats(transcriptPath);
+  await finalizeSession(sessionId, stats, reason);
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("session-end") || process.argv[2] === "session-end";
+if (isDirectRun) {
+  runSessionEndHook().catch(() => process.exit(0));
+}
+export {
+  runSessionEndHook
+};

package/dist/hooks/session-init.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/hooks/session-init.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_SESSION_INIT_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;
+var PROJECT_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;
+          }
+          if (csEnv?.CONTEXTSTREAM_WORKSPACE_ID) {
+            WORKSPACE_ID = csEnv.CONTEXTSTREAM_WORKSPACE_ID;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!WORKSPACE_ID || !PROJECT_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) {
+            WORKSPACE_ID = csConfig.workspace_id;
+          }
+          if (csConfig.project_id && !PROJECT_ID) {
+            PROJECT_ID = csConfig.project_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 fetchSessionContext() {
+  if (!API_KEY) return null;
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    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_rules", "true");
+    url.searchParams.set("include_lessons", "true");
+    url.searchParams.set("include_decisions", "true");
+    url.searchParams.set("include_plans", "true");
+    url.searchParams.set("limit", "5");
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "X-API-Key": API_KEY
+      },
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (response.ok) {
+      return await response.json();
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function formatContext(ctx) {
+  if (!ctx) {
+    return `[ContextStream Session Start]
+
+No stored context found. Call \`mcp__contextstream__context(user_message="starting new session")\` to initialize.`;
+  }
+  const parts = ["[ContextStream Session Start]"];
+  if (ctx.lessons && ctx.lessons.length > 0) {
+    parts.push("\n## \u26A0\uFE0F Lessons from Past Mistakes");
+    for (const lesson of ctx.lessons.slice(0, 3)) {
+      parts.push(`- **${lesson.title}**: ${lesson.prevention}`);
+    }
+  }
+  if (ctx.active_plans && ctx.active_plans.length > 0) {
+    parts.push("\n## \u{1F4CB} Active Plans");
+    for (const plan of ctx.active_plans.slice(0, 3)) {
+      parts.push(`- ${plan.title} (${plan.status})`);
+    }
+  }
+  if (ctx.pending_tasks && ctx.pending_tasks.length > 0) {
+    parts.push("\n## \u2705 Pending Tasks");
+    for (const task of ctx.pending_tasks.slice(0, 5)) {
+      parts.push(`- ${task.title}`);
+    }
+  }
+  if (ctx.recent_decisions && ctx.recent_decisions.length > 0) {
+    parts.push("\n## \u{1F4DD} Recent Decisions");
+    for (const decision of ctx.recent_decisions.slice(0, 3)) {
+      parts.push(`- **${decision.title}**`);
+    }
+  }
+  parts.push("\n---");
+  parts.push('Call `mcp__contextstream__context(user_message="...")` for task-specific context.');
+  return parts.join("\n");
+}
+async function runSessionInitHook() {
+  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 context = await fetchSessionContext();
+  const formattedContext = formatContext(context);
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "SessionStart",
+        additionalContext: formattedContext
+      }
+    })
+  );
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("session-init") || process.argv[2] === "session-init";
+if (isDirectRun) {
+  runSessionInitHook().catch(() => process.exit(0));
+}
+export {
+  runSessionInitHook
+};