@contextstream/mcp-server 0.4.50 → 0.4.51

package/dist/hooks/auto-rules.js

@@ -1,6 +1,12 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
@@ -28,6 +34,7 @@ __export(hooks_config_exports, {
   getClineHooksDir: () => getClineHooksDir,
   getCursorHooksConfigPath: () => getCursorHooksConfigPath,
   getCursorHooksDir: () => getCursorHooksDir,
+  getHookCommand: () => getHookCommand,
   getHooksDir: () => getHooksDir,
   getIndexStatusPath: () => getIndexStatusPath,
   getKiloCodeHooksDir: () => getKiloCodeHooksDir,
@@ -53,6 +60,19 @@ __export(hooks_config_exports, {
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { homedir } from "node:os";
+import { fileURLToPath } from "node:url";
+function getHookCommand(hookName) {
+  try {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const indexPath = path.join(__dirname, "index.js");
+    const fs3 = __require("node:fs");
+    if (fs3.existsSync(indexPath)) {
+      return `node ${indexPath} hook ${hookName}`;
+    }
+  } catch {
+  }
+  return `npx @contextstream/mcp-server hook ${hookName}`;
+}
 function getClaudeSettingsPath(scope, projectPath) {
   if (scope === "user") {
     return path.join(homedir(), ".claude", "settings.json");
@@ -72,19 +92,31 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          command: getHookCommand("user-prompt-submit"),
           timeout: 5
         }
       ]
     }
   ];
+  if (options?.includeOnSaveIntent !== false) {
+    userPromptHooks.push({
+      matcher: "*",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-save-intent"),
+          timeout: 5
+        }
+      ]
+    });
+  }
   if (options?.includeMediaAware !== false) {
     userPromptHooks.push({
       matcher: "*",
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook media-aware",
+          command: getHookCommand("media-aware"),
           timeout: 5
         }
       ]
@@ -97,7 +129,7 @@ function buildHooksConfig(options) {
         hooks: [
           {
             type: "command",
-            command: "npx @contextstream/mcp-server hook pre-tool-use",
+            command: getHookCommand("pre-tool-use"),
             timeout: 5
           }
         ]
@@ -108,12 +140,39 @@ function buildHooksConfig(options) {
   if (options?.includePreCompact !== false) {
     config.PreCompact = [
       {
-        // Match both manual (/compact) and automatic compaction
         matcher: "*",
         hooks: [
           {
             type: "command",
-            command: "npx @contextstream/mcp-server hook pre-compact",
+            command: getHookCommand("pre-compact"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionInit !== false) {
+    config.SessionStart = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-init"),
+            timeout: 10
+          }
+        ]
+      }
+    ];
+  }
+  if (options?.includeSessionEnd !== false) {
+    config.Stop = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("session-end"),
             timeout: 10
           }
         ]
@@ -127,7 +186,7 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook post-write",
+          command: getHookCommand("post-write"),
           timeout: 10
         }
       ]
@@ -139,12 +198,60 @@ function buildHooksConfig(options) {
       hooks: [
         {
           type: "command",
-          command: "npx @contextstream/mcp-server hook auto-rules",
+          command: getHookCommand("auto-rules"),
           timeout: 15
         }
       ]
     });
   }
+  if (options?.includeOnBash !== false) {
+    postToolUseHooks.push({
+      matcher: "Bash",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-bash"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnTask !== false) {
+    postToolUseHooks.push({
+      matcher: "Task",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-task"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnRead !== false) {
+    postToolUseHooks.push({
+      matcher: "Read|Glob|Grep",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-read"),
+          timeout: 5
+        }
+      ]
+    });
+  }
+  if (options?.includeOnWeb !== false) {
+    postToolUseHooks.push({
+      matcher: "WebFetch|WebSearch",
+      hooks: [
+        {
+          type: "command",
+          command: getHookCommand("on-web"),
+          timeout: 5
+        }
+      ]
+    });
+  }
   if (postToolUseHooks.length > 0) {
     config.PostToolUse = postToolUseHooks;
   }
@@ -154,17 +261,17 @@ async function installHookScripts(options) {
   const hooksDir = getHooksDir();
   await fs.mkdir(hooksDir, { recursive: true });
   const result = {
-    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
-    userPrompt: "npx @contextstream/mcp-server hook user-prompt-submit"
+    preToolUse: getHookCommand("pre-tool-use"),
+    userPrompt: getHookCommand("user-prompt-submit")
   };
   if (options?.includePreCompact !== false) {
-    result.preCompact = "npx @contextstream/mcp-server hook pre-compact";
+    result.preCompact = getHookCommand("pre-compact");
   }
   if (options?.includeMediaAware !== false) {
-    result.mediaAware = "npx @contextstream/mcp-server hook media-aware";
+    result.mediaAware = getHookCommand("media-aware");
   }
   if (options?.includeAutoRules !== false) {
-    result.autoRules = "npx @contextstream/mcp-server hook auto-rules";
+    result.autoRules = getHookCommand("auto-rules");
   }
   return result;
 }
@@ -200,20 +307,20 @@ function mergeHooksIntoSettings(existingSettings, newHooks) {
 async function installClaudeCodeHooks(options) {
   const result = { scripts: [], settings: [] };
   result.scripts.push(
-    "npx @contextstream/mcp-server hook pre-tool-use",
-    "npx @contextstream/mcp-server hook user-prompt-submit"
+    getHookCommand("pre-tool-use"),
+    getHookCommand("user-prompt-submit")
   );
   if (options.includePreCompact !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook pre-compact");
+    result.scripts.push(getHookCommand("pre-compact"));
   }
   if (options.includeMediaAware !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook media-aware");
+    result.scripts.push(getHookCommand("media-aware"));
   }
   if (options.includePostWrite !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook post-write");
+    result.scripts.push(getHookCommand("post-write"));
   }
   if (options.includeAutoRules !== false) {
-    result.scripts.push("npx @contextstream/mcp-server hook auto-rules");
+    result.scripts.push(getHookCommand("auto-rules"));
   }
   const hooksConfig = buildHooksConfig({
     includePreCompact: options.includePreCompact,
@@ -491,6 +598,8 @@ async function installCursorHookScripts(options) {
   };
   const filteredPreToolUse = filterContextStreamHooks(existingConfig.hooks.preToolUse);
   const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
+  const preToolUseCommand = getHookCommand("pre-tool-use");
+  const userPromptCommand = getHookCommand("user-prompt-submit");
   const config = {
     version: 1,
     hooks: {
@@ -498,7 +607,7 @@ async function installCursorHookScripts(options) {
       preToolUse: [
         ...filteredPreToolUse,
         {
-          command: "npx @contextstream/mcp-server hook pre-tool-use",
+          command: preToolUseCommand,
           type: "command",
           timeout: 5,
           matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
@@ -507,7 +616,7 @@ async function installCursorHookScripts(options) {
       beforeSubmitPrompt: [
         ...filteredBeforeSubmit,
         {
-          command: "npx @contextstream/mcp-server hook user-prompt-submit",
+          command: userPromptCommand,
           type: "command",
           timeout: 5
         }
@@ -517,8 +626,8 @@ async function installCursorHookScripts(options) {
   await writeCursorHooksConfig(config, options.scope, options.projectPath);
   const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
   return {
-    preToolUse: "npx @contextstream/mcp-server hook pre-tool-use",
-    beforeSubmitPrompt: "npx @contextstream/mcp-server hook user-prompt-submit",
+    preToolUse: preToolUseCommand,
+    beforeSubmitPrompt: userPromptCommand,
     config: configPath
   };
 }
@@ -1327,11 +1436,13 @@ esac
 
 exit 0
 `;
-    CLINE_HOOK_WRAPPER = (hookName) => `#!/bin/bash
+    CLINE_HOOK_WRAPPER = (hookName) => {
+      const command = getHookCommand(hookName);
+      return `#!/bin/bash
 # ContextStream ${hookName} Hook Wrapper for Cline/Roo/Kilo Code
-# Calls the Node.js hook via npx
-exec npx @contextstream/mcp-server hook ${hookName}
+exec ${command}
 `;
+    };
     CURSOR_PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
 ContextStream PreToolUse Hook for Cursor

package/dist/hooks/on-bash.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+
+// src/hooks/on-bash.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_BASH_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 captureCommand(command, output, exitCode, isError, sessionId) {
+  if (!API_KEY) return;
+  const payload = {
+    event_type: isError ? "bash_error" : "bash_command",
+    title: isError ? `Bash Error: ${command.slice(0, 50)}...` : `Command: ${command.slice(0, 50)}...`,
+    content: JSON.stringify({
+      command,
+      output: output.slice(0, 2e3),
+      exit_code: exitCode,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: isError ? "high" : "low",
+    tags: isError ? ["bash", "error", "command"] : ["bash", "command"],
+    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 suggestLesson(command, error) {
+  const errorPatterns = [
+    {
+      pattern: /command not found/i,
+      lesson: `The command "${command.split(" ")[0]}" is not installed. Check if the package needs to be installed first.`
+    },
+    {
+      pattern: /permission denied/i,
+      lesson: "Permission denied. May need sudo or to check file permissions."
+    },
+    {
+      pattern: /no such file or directory/i,
+      lesson: "Path does not exist. Verify the file/directory path before running commands."
+    },
+    {
+      pattern: /EADDRINUSE|address already in use/i,
+      lesson: "Port is already in use. Kill the existing process or use a different port."
+    },
+    {
+      pattern: /npm ERR!|ERESOLVE/i,
+      lesson: "npm dependency conflict. Try `npm install --legacy-peer-deps` or check package versions."
+    },
+    {
+      pattern: /ENOENT.*package\.json/i,
+      lesson: "No package.json found. Make sure you're in the right directory or run `npm init`."
+    },
+    {
+      pattern: /git.*not a git repository/i,
+      lesson: "Not in a git repository. Run `git init` or navigate to a git repo."
+    }
+  ];
+  for (const { pattern, lesson } of errorPatterns) {
+    if (pattern.test(error)) {
+      return lesson;
+    }
+  }
+  return null;
+}
+async function runOnBashHook() {
+  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 !== "Bash") {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const command = input.tool_input?.command || "";
+  const output = input.tool_result?.output || input.tool_result?.error || "";
+  const exitCode = input.tool_result?.exit_code ?? 0;
+  const sessionId = input.session_id || "unknown";
+  const isError = exitCode !== 0 || !!input.tool_result?.error;
+  captureCommand(command, output, exitCode, isError, sessionId).catch(() => {
+  });
+  if (isError) {
+    const lesson = await suggestLesson(command, output);
+    if (lesson) {
+      console.log(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: `[ContextStream Insight] ${lesson}`
+          }
+        })
+      );
+      process.exit(0);
+    }
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-bash") || process.argv[2] === "on-bash";
+if (isDirectRun) {
+  runOnBashHook().catch(() => process.exit(0));
+}
+export {
+  runOnBashHook
+};

package/dist/hooks/on-read.js

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+
+// src/hooks/on-read.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_READ_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;
+var recentCaptures = /* @__PURE__ */ new Set();
+var CAPTURE_WINDOW_MS = 6e4;
+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 captureExploration(toolName, target, resultSummary, sessionId) {
+  if (!API_KEY) return;
+  const cacheKey = `${toolName}:${target}`;
+  if (recentCaptures.has(cacheKey)) {
+    return;
+  }
+  recentCaptures.add(cacheKey);
+  setTimeout(() => recentCaptures.delete(cacheKey), CAPTURE_WINDOW_MS);
+  const payload = {
+    event_type: "file_exploration",
+    title: `${toolName}: ${target.slice(0, 50)}`,
+    content: JSON.stringify({
+      tool: toolName,
+      target,
+      result_summary: resultSummary.slice(0, 500),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }),
+    importance: "low",
+    tags: ["exploration", 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 runOnReadHook() {
+  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 (!["Read", "Glob", "Grep"].includes(toolName)) {
+    process.exit(0);
+  }
+  const cwd = input.cwd || process.cwd();
+  loadConfigFromMcpJson(cwd);
+  const sessionId = input.session_id || "unknown";
+  let target = "";
+  let resultSummary = "";
+  switch (toolName) {
+    case "Read":
+      target = input.tool_input?.file_path || "";
+      resultSummary = `Read file: ${target}`;
+      break;
+    case "Glob":
+      target = input.tool_input?.pattern || "";
+      const globFiles = input.tool_result?.files || [];
+      resultSummary = `Found ${globFiles.length} files matching ${target}`;
+      break;
+    case "Grep":
+      target = input.tool_input?.pattern || "";
+      const matches = input.tool_result?.matches || 0;
+      resultSummary = `Found ${matches} matches for "${target}"`;
+      break;
+  }
+  if (target) {
+    captureExploration(toolName, target, resultSummary, sessionId).catch(() => {
+    });
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("on-read") || process.argv[2] === "on-read";
+if (isDirectRun) {
+  runOnReadHook().catch(() => process.exit(0));
+}
+export {
+  runOnReadHook
+};