@contextstream/mcp-server 0.4.62 → 0.4.64

package/dist/hooks/post-tool-use-failure.js

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+
+// src/hooks/post-tool-use-failure.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+// src/hooks/common.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var DEFAULT_API_URL = "https://api.contextstream.io";
+function readHookInput() {
+  try {
+    return JSON.parse(fs.readFileSync(0, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeHookOutput(output) {
+  const payload = output && (output.additionalContext || output.blocked || output.reason) ? {
+    hookSpecificOutput: output.additionalContext ? {
+      hookEventName: output.hookEventName,
+      additionalContext: output.additionalContext
+    } : void 0,
+    additionalContext: output.additionalContext,
+    blocked: output.blocked,
+    reason: output.reason
+  } : {};
+  console.log(JSON.stringify(payload));
+}
+function extractCwd(input) {
+  const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : process.cwd();
+  return cwd;
+}
+function loadHookConfig(cwd) {
+  let apiUrl = process.env.CONTEXTSTREAM_API_URL || DEFAULT_API_URL;
+  let apiKey = process.env.CONTEXTSTREAM_API_KEY || "";
+  let jwt = process.env.CONTEXTSTREAM_JWT || "";
+  let workspaceId = process.env.CONTEXTSTREAM_WORKSPACE_ID || null;
+  let projectId = process.env.CONTEXTSTREAM_PROJECT_ID || null;
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 6; i++) {
+    if (!apiKey && !jwt) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const config = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+          const env = config.mcpServers?.contextstream?.env;
+          if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+          if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+          if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+          if (env?.CONTEXTSTREAM_WORKSPACE_ID && !workspaceId) workspaceId = env.CONTEXTSTREAM_WORKSPACE_ID;
+          if (env?.CONTEXTSTREAM_PROJECT_ID && !projectId) projectId = env.CONTEXTSTREAM_PROJECT_ID;
+        } catch {
+        }
+      }
+    }
+    if (!workspaceId || !projectId) {
+      const localConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(localConfigPath)) {
+        try {
+          const localConfig = JSON.parse(fs.readFileSync(localConfigPath, "utf8"));
+          if (localConfig.workspace_id && !workspaceId) workspaceId = localConfig.workspace_id;
+          if (localConfig.project_id && !projectId) projectId = localConfig.project_id;
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!apiKey && !jwt) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(homeMcpPath, "utf8"));
+        const env = config.mcpServers?.contextstream?.env;
+        if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+        if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+        if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+      } catch {
+      }
+    }
+  }
+  return { apiUrl, apiKey, jwt, workspaceId, projectId };
+}
+function isConfigured(config) {
+  return Boolean(config.apiKey || config.jwt);
+}
+function authHeaders(config) {
+  if (config.apiKey) {
+    return { "X-API-Key": config.apiKey };
+  }
+  if (config.jwt) {
+    return { Authorization: `Bearer ${config.jwt}` };
+  }
+  return {};
+}
+async function apiRequest(config, apiPath, init = {}) {
+  const response = await fetch(`${config.apiUrl}${apiPath}`, {
+    method: init.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...authHeaders(config)
+    },
+    body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json && typeof json === "object" && "data" in json) {
+    return json.data;
+  }
+  return json;
+}
+async function postMemoryEvent(config, title, content, tags, eventType = "operation") {
+  if (!isConfigured(config) || !config.workspaceId) return;
+  await apiRequest(config, "/memory/events", {
+    method: "POST",
+    body: {
+      workspace_id: config.workspaceId,
+      project_id: config.projectId || void 0,
+      event_type: eventType,
+      title,
+      content: typeof content === "string" ? content : JSON.stringify(content),
+      metadata: {
+        tags,
+        source: "mcp_hook",
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+}
+
+// src/hooks/post-tool-use-failure.ts
+var FAILURE_COUNTERS_FILE = path2.join(homedir2(), ".contextstream", "hook-failure-counts.json");
+function extractErrorText(input) {
+  return typeof input.error === "string" && input.error || typeof input.tool_error === "string" && input.tool_error || typeof input.stderr === "string" && input.stderr || "Tool execution failed";
+}
+function failureFingerprint(toolName, errorText) {
+  const compact = errorText.split(/\s+/).slice(0, 18).join(" ").toLowerCase();
+  return `${toolName.toLowerCase()}:${compact}`;
+}
+function incrementFailureCounter(fingerprint) {
+  let counters = {};
+  try {
+    counters = JSON.parse(fs2.readFileSync(FAILURE_COUNTERS_FILE, "utf8"));
+  } catch {
+    counters = {};
+  }
+  counters[fingerprint] = (counters[fingerprint] || 0) + 1;
+  fs2.mkdirSync(path2.dirname(FAILURE_COUNTERS_FILE), { recursive: true });
+  fs2.writeFileSync(FAILURE_COUNTERS_FILE, JSON.stringify(counters, null, 2), "utf8");
+  return counters[fingerprint];
+}
+async function runPostToolUseFailureHook() {
+  const input = readHookInput();
+  const cwd = extractCwd(input);
+  const config = loadHookConfig(cwd);
+  const toolName = typeof input.tool_name === "string" && input.tool_name || typeof input.toolName === "string" && input.toolName || "unknown";
+  const errorText = extractErrorText(input);
+  const toolUseId = typeof input.tool_use_id === "string" && input.tool_use_id || typeof input.toolUseId === "string" && input.toolUseId || "";
+  const fingerprint = failureFingerprint(toolName, errorText);
+  const count = incrementFailureCounter(fingerprint);
+  if (isConfigured(config)) {
+    await postMemoryEvent(
+      config,
+      `Tool failure: ${toolName}`,
+      {
+        tool_name: toolName,
+        tool_use_id: toolUseId || null,
+        error: errorText,
+        fingerprint,
+        occurrence_count: count,
+        tool_input: input.tool_input || {},
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ["hook", "post_tool_use_failure", "tool_error"]
+    ).catch(() => {
+    });
+    const autoLessonEnabled = process.env.CONTEXTSTREAM_FAILURE_AUTO_LESSON !== "false";
+    if (autoLessonEnabled && count >= 3) {
+      await postMemoryEvent(
+        config,
+        `Recurring failure lesson: ${toolName}`,
+        {
+          title: `Recurring failure in ${toolName}`,
+          trigger: errorText,
+          prevention: "Add guardrails or alternate fallback path for this failure mode.",
+          occurrences: count,
+          fingerprint
+        },
+        ["hook", "lesson", "recurring_failure"],
+        "lesson"
+      ).catch(() => {
+      });
+    }
+  }
+  writeHookOutput();
+}
+var isDirectRun = process.argv[1]?.includes("post-tool-use-failure") || process.argv[2] === "post-tool-use-failure";
+if (isDirectRun) {
+  runPostToolUseFailureHook().catch(() => process.exit(0));
+}
+export {
+  runPostToolUseFailureHook
+};

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

@@ -141,7 +141,7 @@ function isContextFreshAndClean(cwd, maxAgeSeconds) {
   if (ageSeconds < 0 || ageSeconds > maxAgeSeconds) return false;
   if (entry.last_state_change_at) {
     const changedAt = new Date(entry.last_state_change_at);
-    if (!Number.isNaN(changedAt.getTime()) && changedAt.getTime() > contextAt.getTime()) {
+    if (!Number.isNaN(changedAt.getTime()) && changedAt.getTime() >= contextAt.getTime()) {
       return false;
     }
   }
@@ -485,9 +485,18 @@ async function runPreToolUseHook() {
         blockClaudeCode(msg);
       }
     }
+  } else if (tool === "Explore") {
+    const msg = 'Project index is current. Use mcp__contextstream__search(mode="auto", output_format="paths") instead of Explore for broad discovery.';
+    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 subagentTypeRaw = toolInput?.subagent_type || toolInput?.subagentType || "";
+    const subagentType = subagentTypeRaw.toLowerCase();
+    if (subagentType.includes("explore")) {
       const msg = 'Project index is current. Use mcp__contextstream__search(mode="auto") instead of Task(Explore) for broad discovery.';
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream search for code discovery.");
@@ -496,8 +505,8 @@ async function runPreToolUseHook() {
       }
       blockClaudeCode(msg);
     }
-    if (subagentType === "plan") {
-      const msg = 'After your plan is ready, save it with mcp__contextstream__session(action="capture_plan"). Then create tasks with mcp__contextstream__memory(action="create_task", title="...", plan_id="...").';
+    if (subagentType.includes("plan")) {
+      const msg = 'For planning, use mcp__contextstream__search(mode="auto", output_format="paths") for discovery, then save your plan with mcp__contextstream__session(action="capture_plan"). Then create tasks with mcp__contextstream__memory(action="create_task", title="...", plan_id="...").';
       if (editorFormat === "cline") {
         outputClineBlock(msg, "[CONTEXTSTREAM] Use ContextStream plans for persistence.");
       } else if (editorFormat === "cursor") {