@contextstream/mcp-server 0.4.81 → 1.0.0

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
-};

package/dist/hooks/post-write.js

@@ -1,348 +0,0 @@
-#!/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 = 5 * 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}`);
-  }
-  try {
-    const body = await response.json();
-    if (body?.data?.status === "cooldown" || body?.data?.status === "daily_limit_exceeded") {
-      return;
-    }
-  } catch {
-  }
-}
-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
-};