@contextstream/mcp-server 0.4.44 → 0.4.45

package/dist/hooks/media-aware.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+// src/hooks/media-aware.ts
+var ENABLED = process.env.CONTEXTSTREAM_MEDIA_HOOK_ENABLED !== "false";
+var PATTERNS = [
+  /\b(video|videos|clip|clips|footage|keyframe)s?\b/i,
+  /\b(remotion|timeline|video\s*edit)\b/i,
+  /\b(image|images|photo|photos|picture|thumbnail)s?\b/i,
+  /\b(audio|podcast|transcript|transcription|voice)\b/i,
+  /\b(media|asset|assets|creative|b-roll)\b/i,
+  /\b(find|search|show).*(clip|video|image|audio|footage|media)\b/i
+];
+var MEDIA_CONTEXT = `[MEDIA TOOLS AVAILABLE]
+Your workspace may have indexed media. Use ContextStream media tools:
+
+- **Search**: \`mcp__contextstream__media(action="search", query="description")\`
+- **Get clip**: \`mcp__contextstream__media(action="get_clip", content_id="...", start="1:34", end="2:15", output_format="remotion|ffmpeg|raw")\`
+- **List assets**: \`mcp__contextstream__media(action="list")\`
+- **Index**: \`mcp__contextstream__media(action="index", file_path="...", content_type="video|audio|image|document")\`
+
+For Remotion: use \`output_format="remotion"\` to get frame-based props.
+[END MEDIA TOOLS]`;
+function matchesMediaPattern(text) {
+  return PATTERNS.some((pattern) => pattern.test(text));
+}
+function extractPrompt(input) {
+  if (input.prompt) {
+    return input.prompt;
+  }
+  if (input.session?.messages) {
+    for (let i = input.session.messages.length - 1; i >= 0; i--) {
+      const msg = input.session.messages[i];
+      if (msg.role === "user") {
+        if (typeof msg.content === "string") {
+          return msg.content;
+        }
+        if (Array.isArray(msg.content)) {
+          for (const block of msg.content) {
+            if (block.type === "text" && block.text) {
+              return block.text;
+            }
+          }
+        }
+        break;
+      }
+    }
+  }
+  return "";
+}
+function detectEditorFormat(input) {
+  if (input.hookName !== void 0) {
+    return "cline";
+  }
+  return "claude";
+}
+async function runMediaAwareHook() {
+  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 prompt = extractPrompt(input);
+  if (!prompt || !matchesMediaPattern(prompt)) {
+    process.exit(0);
+  }
+  const editorFormat = detectEditorFormat(input);
+  if (editorFormat === "claude") {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: MEDIA_CONTEXT
+        }
+      })
+    );
+  } else {
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: MEDIA_CONTEXT
+      })
+    );
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("media-aware") || process.argv[2] === "media-aware";
+if (isDirectRun) {
+  runMediaAwareHook().catch(() => process.exit(0));
+}
+export {
+  runMediaAwareHook
+};

package/dist/hooks/post-write.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+
+// src/hooks/post-write.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var API_URL = process.env.CONTEXTSTREAM_API_URL || "https://api.contextstream.io";
+var API_KEY = process.env.CONTEXTSTREAM_API_KEY || "";
+var ENABLED = process.env.CONTEXTSTREAM_POSTWRITE_ENABLED !== "false";
+var INDEXABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".pyw",
+  ".rs",
+  ".go",
+  ".java",
+  ".kt",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".fs",
+  ".vb",
+  ".rb",
+  ".php",
+  ".pl",
+  ".pm",
+  ".swift",
+  ".m",
+  ".mm",
+  ".lua",
+  ".r",
+  ".jl",
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".ini",
+  ".cfg",
+  ".md",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".tf",
+  ".hcl",
+  ".dockerfile",
+  ".containerfile",
+  ".prisma",
+  ".proto"
+]);
+var MAX_FILE_SIZE = 1024 * 1024;
+function extractFilePath(input) {
+  if (input.tool_input) {
+    const filePath = input.tool_input.file_path || input.tool_input.notebook_path || input.tool_input.path;
+    if (filePath) return filePath;
+  }
+  if (input.parameters) {
+    const filePath = input.parameters.path || input.parameters.file_path;
+    if (filePath) return filePath;
+  }
+  if (input.toolParameters?.path) {
+    return input.toolParameters.path;
+  }
+  if (input.file_path) {
+    return input.file_path;
+  }
+  return null;
+}
+function extractCwd(input) {
+  if (input.cwd) return input.cwd;
+  if (input.workspace_roots?.length) return input.workspace_roots[0];
+  if (input.workspaceRoots?.length) return input.workspaceRoots[0];
+  return process.cwd();
+}
+function findLocalConfig(startDir) {
+  let currentDir = path.resolve(startDir);
+  for (let i = 0; i < 10; i++) {
+    const configPath = path.join(currentDir, ".contextstream", "config.json");
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        return JSON.parse(content);
+      } catch {
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+function loadApiConfig(startDir) {
+  let apiUrl = API_URL;
+  let apiKey = API_KEY;
+  if (apiKey) {
+    return { apiUrl, apiKey };
+  }
+  let currentDir = path.resolve(startDir);
+  for (let i = 0; i < 10; i++) {
+    const mcpPath = path.join(currentDir, ".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) {
+          apiKey = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          apiUrl = csEnv.CONTEXTSTREAM_API_URL;
+        }
+        if (apiKey) break;
+      } catch {
+      }
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  if (!apiKey) {
+    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) {
+          apiKey = csEnv.CONTEXTSTREAM_API_KEY;
+        }
+        if (csEnv?.CONTEXTSTREAM_API_URL) {
+          apiUrl = csEnv.CONTEXTSTREAM_API_URL;
+        }
+      } catch {
+      }
+    }
+  }
+  return { apiUrl, apiKey };
+}
+function shouldIndexFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (!INDEXABLE_EXTENSIONS.has(ext)) {
+    const basename2 = path.basename(filePath).toLowerCase();
+    if (!["dockerfile", "makefile", "rakefile", "gemfile", "procfile"].includes(basename2)) {
+      return false;
+    }
+  }
+  try {
+    const stats = fs.statSync(filePath);
+    if (stats.size > MAX_FILE_SIZE) {
+      return false;
+    }
+  } catch {
+    return false;
+  }
+  return true;
+}
+function detectLanguage(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".pyw": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".scala": "scala",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".fs": "fsharp",
+    ".vb": "vb",
+    ".rb": "ruby",
+    ".php": "php",
+    ".pl": "perl",
+    ".pm": "perl",
+    ".swift": "swift",
+    ".m": "objective-c",
+    ".mm": "objective-cpp",
+    ".lua": "lua",
+    ".r": "r",
+    ".jl": "julia",
+    ".sh": "shell",
+    ".bash": "shell",
+    ".zsh": "shell",
+    ".fish": "shell",
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".xml": "xml",
+    ".ini": "ini",
+    ".cfg": "ini",
+    ".md": "markdown",
+    ".mdx": "mdx",
+    ".txt": "text",
+    ".rst": "rst",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".astro": "astro",
+    ".tf": "terraform",
+    ".hcl": "hcl",
+    ".prisma": "prisma",
+    ".proto": "protobuf"
+  };
+  return langMap[ext] || "text";
+}
+async function indexFile(filePath, projectId, apiUrl, apiKey, projectRoot) {
+  const content = fs.readFileSync(filePath, "utf-8");
+  const relativePath = path.relative(projectRoot, filePath);
+  const payload = {
+    files: [
+      {
+        path: relativePath,
+        content,
+        language: detectLanguage(filePath)
+      }
+    ]
+  };
+  const response = await fetch(`${apiUrl}/api/v1/projects/${projectId}/files/ingest`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-API-Key": apiKey
+    },
+    body: JSON.stringify(payload),
+    signal: AbortSignal.timeout(1e4)
+    // 10 second timeout
+  });
+  if (!response.ok) {
+    throw new Error(`API error: ${response.status} ${response.statusText}`);
+  }
+}
+function findProjectRoot(filePath) {
+  let currentDir = path.dirname(path.resolve(filePath));
+  for (let i = 0; i < 10; i++) {
+    const configPath = path.join(currentDir, ".contextstream", "config.json");
+    if (fs.existsSync(configPath)) {
+      return currentDir;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function runPostWriteHook() {
+  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 filePath = extractFilePath(input);
+  if (!filePath) {
+    process.exit(0);
+  }
+  const cwd = extractCwd(input);
+  const absolutePath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
+  if (!fs.existsSync(absolutePath) || !shouldIndexFile(absolutePath)) {
+    process.exit(0);
+  }
+  const projectRoot = findProjectRoot(absolutePath);
+  if (!projectRoot) {
+    process.exit(0);
+  }
+  const localConfig = findLocalConfig(projectRoot);
+  if (!localConfig?.project_id) {
+    process.exit(0);
+  }
+  const { apiUrl, apiKey } = loadApiConfig(projectRoot);
+  if (!apiKey) {
+    process.exit(0);
+  }
+  try {
+    await indexFile(absolutePath, localConfig.project_id, apiUrl, apiKey, projectRoot);
+  } catch {
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("post-write") || process.argv[2] === "post-write";
+if (isDirectRun) {
+  runPostWriteHook().catch(() => process.exit(0));
+}
+export {
+  runPostWriteHook
+};

package/dist/hooks/pre-compact.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+
+// src/hooks/pre-compact.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_PRECOMPACT_ENABLED !== "false";
+var AUTO_SAVE = process.env.CONTEXTSTREAM_PRECOMPACT_AUTO_SAVE !== "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 parseTranscript(transcriptPath) {
+  const activeFiles = /* @__PURE__ */ new Set();
+  const recentMessages = [];
+  const toolCalls = [];
+  try {
+    const content = fs.readFileSync(transcriptPath, "utf-8");
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        const msgType = entry.type || "";
+        if (msgType === "tool_use") {
+          const toolName = entry.name || "";
+          const toolInput = entry.input || {};
+          toolCalls.push({ name: toolName, input: toolInput });
+          if (["Read", "Write", "Edit", "NotebookEdit"].includes(toolName)) {
+            const filePath = toolInput.file_path || toolInput.notebook_path;
+            if (filePath) {
+              activeFiles.add(filePath);
+            }
+          } else if (toolName === "Glob") {
+            const pattern = toolInput.pattern;
+            if (pattern) {
+              activeFiles.add(`[glob:${pattern}]`);
+            }
+          }
+        }
+        if (msgType === "assistant" && entry.content) {
+          const content2 = entry.content;
+          if (typeof content2 === "string" && content2.length > 50) {
+            recentMessages.push(content2.slice(0, 500));
+          }
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+  }
+  return {
+    activeFiles: Array.from(activeFiles).slice(-20),
+    // Last 20 files
+    toolCallCount: toolCalls.length,
+    messageCount: recentMessages.length,
+    lastTools: toolCalls.slice(-10).map((t) => t.name)
+    // Last 10 tool names
+  };
+}
+async function saveSnapshot(sessionId, transcriptData, trigger) {
+  if (!API_KEY) {
+    return { success: false, message: "No API key configured" };
+  }
+  const snapshotContent = {
+    session_id: sessionId,
+    trigger,
+    captured_at: null,
+    // API will set timestamp
+    active_files: transcriptData.activeFiles,
+    tool_call_count: transcriptData.toolCallCount,
+    last_tools: transcriptData.lastTools,
+    auto_captured: true
+  };
+  const payload = {
+    event_type: "session_snapshot",
+    title: `Auto Pre-compaction Snapshot (${trigger})`,
+    content: JSON.stringify(snapshotContent),
+    importance: "high",
+    tags: ["session_snapshot", "pre_compaction", "auto_captured"],
+    source_type: "hook"
+  };
+  if (WORKSPACE_ID) {
+    payload.workspace_id = WORKSPACE_ID;
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5e3);
+    const response = 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);
+    if (response.ok) {
+      return { success: true, message: "Snapshot saved" };
+    }
+    return { success: false, message: `API error: ${response.status}` };
+  } catch (error) {
+    return { success: false, message: String(error) };
+  }
+}
+async function runPreCompactHook() {
+  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 trigger = input.trigger || "unknown";
+  const customInstructions = input.custom_instructions || "";
+  let transcriptData = {
+    activeFiles: [],
+    toolCallCount: 0,
+    messageCount: 0,
+    lastTools: []
+  };
+  if (transcriptPath && fs.existsSync(transcriptPath)) {
+    transcriptData = parseTranscript(transcriptPath);
+  }
+  let autoSaveStatus = "";
+  if (AUTO_SAVE && API_KEY) {
+    const { success, message } = await saveSnapshot(sessionId, transcriptData, trigger);
+    if (success) {
+      autoSaveStatus = `
+[ContextStream: Auto-saved snapshot with ${transcriptData.activeFiles.length} active files]`;
+    } else {
+      autoSaveStatus = `
+[ContextStream: Auto-save failed - ${message}]`;
+    }
+  }
+  const filesList = transcriptData.activeFiles.slice(0, 5).join(", ") || "none detected";
+  const context = `[CONTEXT COMPACTION - ${trigger.toUpperCase()}]${autoSaveStatus}
+
+Active files detected: ${filesList}
+Tool calls in session: ${transcriptData.toolCallCount}
+
+After compaction, call session_init(is_post_compact=true) to restore context.${customInstructions ? `
+User instructions: ${customInstructions}` : ""}`;
+  console.log(
+    JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreCompact",
+        additionalContext: context
+      }
+    })
+  );
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("pre-compact") || process.argv[2] === "pre-compact";
+if (isDirectRun) {
+  runPreCompactHook().catch(() => process.exit(0));
+}
+export {
+  runPreCompactHook
+};