@contextstream/mcp-server 0.4.43 → 0.4.45

package/dist/hooks/pre-tool-use.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+// src/hooks/pre-tool-use.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var ENABLED = process.env.CONTEXTSTREAM_HOOK_ENABLED !== "false";
+var INDEX_STATUS_FILE = path.join(homedir(), ".contextstream", "indexed-projects.json");
+var STALE_THRESHOLD_DAYS = 7;
+var DISCOVERY_PATTERNS = ["**/*", "**/", "src/**", "lib/**", "app/**", "components/**"];
+function isDiscoveryGlob(pattern) {
+  const patternLower = pattern.toLowerCase();
+  for (const p of DISCOVERY_PATTERNS) {
+    if (patternLower.includes(p)) {
+      return true;
+    }
+  }
+  if (patternLower.startsWith("**/*.") || patternLower.startsWith("**/")) {
+    return true;
+  }
+  if (patternLower.includes("**") || patternLower.includes("*/")) {
+    return true;
+  }
+  return false;
+}
+function isDiscoveryGrep(filePath) {
+  if (!filePath || filePath === "." || filePath === "./" || filePath === "*" || filePath === "**") {
+    return true;
+  }
+  if (filePath.includes("*") || filePath.includes("**")) {
+    return true;
+  }
+  return false;
+}
+function isProjectIndexed(cwd) {
+  if (!fs.existsSync(INDEX_STATUS_FILE)) {
+    return { isIndexed: false, isStale: false };
+  }
+  let data;
+  try {
+    const content = fs.readFileSync(INDEX_STATUS_FILE, "utf-8");
+    data = JSON.parse(content);
+  } catch {
+    return { isIndexed: false, isStale: false };
+  }
+  const projects = data.projects || {};
+  const cwdPath = path.resolve(cwd);
+  for (const [projectPath, info] of Object.entries(projects)) {
+    try {
+      const indexedPath = path.resolve(projectPath);
+      if (cwdPath === indexedPath || cwdPath.startsWith(indexedPath + path.sep)) {
+        const indexedAt = info.indexed_at;
+        if (indexedAt) {
+          try {
+            const indexedTime = new Date(indexedAt);
+            const now = /* @__PURE__ */ new Date();
+            const diffDays = (now.getTime() - indexedTime.getTime()) / (1e3 * 60 * 60 * 24);
+            if (diffDays > STALE_THRESHOLD_DAYS) {
+              return { isIndexed: true, isStale: true };
+            }
+          } catch {
+          }
+        }
+        return { isIndexed: true, isStale: false };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { isIndexed: false, isStale: false };
+}
+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 extractToolName(input) {
+  return input.tool_name || input.toolName || "";
+}
+function extractToolInput(input) {
+  return input.tool_input || input.parameters || input.toolParameters || {};
+}
+function blockClaudeCode(message) {
+  console.error(message);
+  process.exit(2);
+}
+function outputClineBlock(errorMessage, contextMod) {
+  const result = {
+    cancel: true,
+    errorMessage
+  };
+  if (contextMod) {
+    result.contextModification = contextMod;
+  }
+  console.log(JSON.stringify(result));
+  process.exit(0);
+}
+function outputClineAllow() {
+  console.log(JSON.stringify({ cancel: false }));
+  process.exit(0);
+}
+function outputCursorBlock(reason) {
+  console.log(JSON.stringify({ decision: "deny", reason }));
+  process.exit(0);
+}
+function outputCursorAllow() {
+  console.log(JSON.stringify({ decision: "allow" }));
+  process.exit(0);
+}
+function detectEditorFormat(input) {
+  if (input.hookName !== void 0 || input.toolName !== void 0) {
+    return "cline";
+  }
+  if (input.hook_event_name !== void 0) {
+    return "cursor";
+  }
+  return "claude";
+}
+async function runPreToolUseHook() {
+  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 editorFormat = detectEditorFormat(input);
+  const cwd = extractCwd(input);
+  const tool = extractToolName(input);
+  const toolInput = extractToolInput(input);
+  const { isIndexed } = isProjectIndexed(cwd);
+  if (!isIndexed) {
+    if (editorFormat === "cline") {
+      outputClineAllow();
+    } else if (editorFormat === "cursor") {
+      outputCursorAllow();
+    }
+    process.exit(0);
+  }
+  if (tool === "Glob") {
+    const pattern = toolInput?.pattern || "";
+    if (isDiscoveryGlob(pattern)) {
+      const msg = `STOP: Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of Glob.`;
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+  } else if (tool === "Grep" || tool === "Search") {
+    const pattern = toolInput?.pattern || "";
+    const filePath = toolInput?.path || "";
+    if (pattern) {
+      if (filePath && !isDiscoveryGrep(filePath)) {
+        const msg = `STOP: Use Read("${filePath}") to view file content, or mcp__contextstream__search(mode="keyword", query="${pattern}") for codebase search.`;
+        if (editorFormat === "cline") {
+          outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+        } else if (editorFormat === "cursor") {
+          outputCursorBlock(msg);
+        }
+        blockClaudeCode(msg);
+      } else {
+        const msg = `STOP: Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of ${tool}.`;
+        if (editorFormat === "cline") {
+          outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+        } else if (editorFormat === "cursor") {
+          outputCursorBlock(msg);
+        }
+        blockClaudeCode(msg);
+      }
+    }
+  } else if (tool === "Task") {
+    const subagentType = toolInput?.subagent_type?.toLowerCase() || "";
+    if (subagentType === "explore") {
+      const msg = 'STOP: Use mcp__contextstream__search(mode="hybrid") instead of Task(Explore).';
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+    if (subagentType === "plan") {
+      const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan") for planning. ContextStream plans persist across sessions.';
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+      blockClaudeCode(msg);
+    }
+  } else if (tool === "EnterPlanMode") {
+    const msg = 'STOP: Use mcp__contextstream__session(action="capture_plan", title="...", steps=[...]) instead of EnterPlanMode. ContextStream plans persist across sessions and are searchable.';
+    if (editorFormat === "cline") {
+      outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
+    } else if (editorFormat === "cursor") {
+      outputCursorBlock(msg);
+    }
+    blockClaudeCode(msg);
+  }
+  if (tool === "list_files" || tool === "search_files") {
+    const pattern = toolInput?.path || toolInput?.regex || "";
+    if (isDiscoveryGlob(pattern) || isDiscoveryGrep(pattern)) {
+      const msg = `Use mcp__contextstream__search(mode="hybrid", query="${pattern}") instead of ${tool}. ContextStream search is indexed and faster.`;
+      if (editorFormat === "cline") {
+        outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
+      } else if (editorFormat === "cursor") {
+        outputCursorBlock(msg);
+      }
+    }
+  }
+  if (editorFormat === "cline") {
+    outputClineAllow();
+  } else if (editorFormat === "cursor") {
+    outputCursorAllow();
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("pre-tool-use") || process.argv[2] === "pre-tool-use";
+if (isDirectRun) {
+  runPreToolUseHook().catch(() => process.exit(0));
+}
+export {
+  runPreToolUseHook
+};

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

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// src/hooks/user-prompt-submit.ts
+var ENABLED = process.env.CONTEXTSTREAM_REMINDER_ENABLED !== "false";
+var REMINDER = `[CONTEXTSTREAM RULES]
+1. BEFORE Glob/Grep/Read/Search: mcp__contextstream__search(mode="hybrid") FIRST
+2. Call context_smart at start of EVERY response
+3. Local tools ONLY if ContextStream returns 0 results
+[END RULES]`;
+function detectEditorFormat(input) {
+  if (input.hookName !== void 0) {
+    return "cline";
+  }
+  if (input.hook_event_name === "beforeSubmitPrompt") {
+    return "cursor";
+  }
+  return "claude";
+}
+async function runUserPromptSubmitHook() {
+  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 editorFormat = detectEditorFormat(input);
+  if (editorFormat === "claude") {
+    console.log(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "UserPromptSubmit",
+          additionalContext: REMINDER
+        }
+      })
+    );
+  } else if (editorFormat === "cline") {
+    console.log(
+      JSON.stringify({
+        cancel: false,
+        contextModification: REMINDER
+      })
+    );
+  } else if (editorFormat === "cursor") {
+    console.log(
+      JSON.stringify({
+        continue: true,
+        user_message: "[CONTEXTSTREAM] Search with mcp__contextstream__search before using Glob/Grep/Read"
+      })
+    );
+  }
+  process.exit(0);
+}
+var isDirectRun = process.argv[1]?.includes("user-prompt-submit") || process.argv[2] === "user-prompt-submit";
+if (isDirectRun) {
+  runUserPromptSubmitHook().catch(() => process.exit(0));
+}
+export {
+  runUserPromptSubmitHook
+};