@contextstream/mcp-server 0.4.82 → 1.0.1

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

@@ -1,213 +0,0 @@
-#!/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";
-var HOOK_SPECIFIC_OUTPUT_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "UserPromptSubmit", "PostToolUse"]);
-function readHookInput() {
-  try {
-    return JSON.parse(fs.readFileSync(0, "utf8"));
-  } catch {
-    return {};
-  }
-}
-function writeHookOutput(output) {
-  const eventName = output?.hookEventName || (typeof process.env.HOOK_EVENT_NAME === "string" ? process.env.HOOK_EVENT_NAME.trim() : "");
-  const canUseHookSpecificOutput = HOOK_SPECIFIC_OUTPUT_EVENTS.has(eventName);
-  const payload = output && (output.additionalContext || output.blocked || output.reason) ? {
-    hookSpecificOutput: output.additionalContext && canUseHookSpecificOutput ? {
-      hookEventName: eventName,
-      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
-};