@contextstream/mcp-server 0.4.82 → 1.0.1

package/dist/hooks/on-read.js

@@ -1,321 +0,0 @@
-#!/usr/bin/env node
-
-// src/hooks/on-read.ts
-import * as fs2 from "node:fs";
-import * as path2 from "node:path";
-import { homedir as homedir2 } from "node:os";
-
-// src/hot-paths.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
-var STORE_VERSION = 1;
-var STORE_DIR = path.join(homedir(), ".contextstream");
-var STORE_FILE = path.join(STORE_DIR, "hot-paths.json");
-var MAX_PATHS_PER_SCOPE = 400;
-var HALF_LIFE_MS = 3 * 24 * 60 * 60 * 1e3;
-function clamp(value, min, max) {
-  return Math.max(min, Math.min(max, value));
-}
-function normalizePathKey(input) {
-  return input.replace(/\\/g, "/").trim();
-}
-function toScopeKey(input) {
-  const workspace = input.workspace_id || "none";
-  const project = input.project_id || "none";
-  return `${workspace}:${project}`;
-}
-function signalWeight(signal) {
-  switch (signal) {
-    case "search_result":
-      return 1.8;
-    case "activity_edit":
-      return 1.4;
-    case "activity_focus":
-      return 1.2;
-    case "activity_read":
-    default:
-      return 1;
-  }
-}
-function looksBroadQuery(query) {
-  const q = query.trim().toLowerCase();
-  if (!q) return true;
-  if (q.length <= 2) return true;
-  if (/^\*+$/.test(q) || q === "all files" || q === "everything") return true;
-  const tokens = q.split(/\s+/).filter(Boolean);
-  return tokens.length > 12;
-}
-var HotPathStore = class {
-  constructor() {
-    this.data = { version: STORE_VERSION, scopes: {} };
-    this.load();
-  }
-  recordPaths(scope, paths, signal) {
-    if (paths.length === 0) return;
-    const now = Date.now();
-    const scopeKey = toScopeKey(scope);
-    const profile = this.ensureScope(scopeKey);
-    const weight = signalWeight(signal);
-    for (const raw of paths) {
-      const pathKey = normalizePathKey(raw);
-      if (!pathKey) continue;
-      const current = profile.paths[pathKey] || { score: 0, last_seen: now, hits: 0 };
-      const decayed = this.decayedScore(current.score, current.last_seen, now);
-      profile.paths[pathKey] = {
-        score: decayed + weight,
-        last_seen: now,
-        hits: current.hits + 1
-      };
-    }
-    profile.updated_at = now;
-    this.pruneScope(profile);
-    this.persist();
-  }
-  buildHint(input) {
-    const scopeKey = toScopeKey(input);
-    const profile = this.data.scopes[scopeKey];
-    if (!profile) return void 0;
-    const now = Date.now();
-    const baseEntries = Object.entries(profile.paths).map(([filePath, entry]) => ({
-      path: filePath,
-      score: this.decayedScore(entry.score, entry.last_seen, now)
-    })).filter((entry) => entry.score > 0.05).sort((a, b) => b.score - a.score);
-    const active = (input.active_paths || []).map(normalizePathKey).filter(Boolean);
-    const merged = /* @__PURE__ */ new Map();
-    for (const entry of baseEntries.slice(0, Math.max(12, input.limit || 8))) {
-      merged.set(entry.path, {
-        path: entry.path,
-        score: Number(entry.score.toFixed(4)),
-        source: "history"
-      });
-    }
-    for (const activePath of active) {
-      const existing = merged.get(activePath);
-      if (existing) {
-        existing.score = Number((existing.score + 0.9).toFixed(4));
-      } else {
-        merged.set(activePath, { path: activePath, score: 0.9, source: "active" });
-      }
-    }
-    const limit = clamp(input.limit ?? 8, 1, 12);
-    const entries = [...merged.values()].sort((a, b) => b.score - a.score).slice(0, limit);
-    if (entries.length === 0) return void 0;
-    const scoreSum = entries.reduce((sum, item) => sum + item.score, 0);
-    const normalized = clamp(scoreSum / (limit * 2.5), 0, 1);
-    const confidencePenalty = looksBroadQuery(input.query) ? 0.55 : 1;
-    const confidence = Number((normalized * confidencePenalty).toFixed(3));
-    return {
-      entries,
-      confidence,
-      generated_at: new Date(now).toISOString(),
-      profile_version: STORE_VERSION
-    };
-  }
-  decayedScore(score, lastSeenMs, nowMs) {
-    const elapsed = Math.max(0, nowMs - lastSeenMs);
-    const decay = Math.pow(0.5, elapsed / HALF_LIFE_MS);
-    return score * decay;
-  }
-  ensureScope(scopeKey) {
-    if (!this.data.scopes[scopeKey]) {
-      this.data.scopes[scopeKey] = { paths: {}, updated_at: Date.now() };
-    }
-    return this.data.scopes[scopeKey];
-  }
-  pruneScope(profile) {
-    const entries = Object.entries(profile.paths);
-    if (entries.length <= MAX_PATHS_PER_SCOPE) return;
-    entries.sort((a, b) => b[1].score - a[1].score).slice(MAX_PATHS_PER_SCOPE).forEach(([key]) => delete profile.paths[key]);
-  }
-  load() {
-    try {
-      if (!fs.existsSync(STORE_FILE)) return;
-      const parsed = JSON.parse(fs.readFileSync(STORE_FILE, "utf-8"));
-      if (parsed?.version !== STORE_VERSION || !parsed.scopes) return;
-      this.data = parsed;
-    } catch {
-    }
-  }
-  persist() {
-    try {
-      fs.mkdirSync(STORE_DIR, { recursive: true });
-      fs.writeFileSync(STORE_FILE, JSON.stringify(this.data));
-    } catch {
-    }
-  }
-};
-var globalHotPathStore = new HotPathStore();
-
-// src/hooks/on-read.ts
-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 = path2.resolve(cwd);
-  for (let i = 0; i < 5; i++) {
-    if (!API_KEY) {
-      const mcpPath = path2.join(searchDir, ".mcp.json");
-      if (fs2.existsSync(mcpPath)) {
-        try {
-          const content = fs2.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 = path2.join(searchDir, ".contextstream", "config.json");
-      if (fs2.existsSync(csConfigPath)) {
-        try {
-          const content = fs2.readFileSync(csConfigPath, "utf-8");
-          const csConfig = JSON.parse(content);
-          if (csConfig.workspace_id) {
-            WORKSPACE_ID = csConfig.workspace_id;
-          }
-        } catch {
-        }
-      }
-    }
-    const parentDir = path2.dirname(searchDir);
-    if (parentDir === searchDir) break;
-    searchDir = parentDir;
-  }
-  if (!API_KEY) {
-    const homeMcpPath = path2.join(homedir2(), ".mcp.json");
-    if (fs2.existsSync(homeMcpPath)) {
-      try {
-        const content = fs2.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}`;
-      if (target) {
-        globalHotPathStore.recordPaths(
-          { workspace_id: WORKSPACE_ID || void 0, project_id: void 0 },
-          [target],
-          "activity_read"
-        );
-      }
-      break;
-    case "Glob":
-      target = input.tool_input?.pattern || "";
-      const globFiles = input.tool_result?.files || [];
-      resultSummary = `Found ${globFiles.length} files matching ${target}`;
-      if (globFiles.length > 0) {
-        globalHotPathStore.recordPaths(
-          { workspace_id: WORKSPACE_ID || void 0, project_id: void 0 },
-          globFiles.slice(0, 30),
-          "activity_focus"
-        );
-      }
-      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
-};

package/dist/hooks/on-save-intent.js

@@ -1,132 +0,0 @@
-#!/usr/bin/env node
-
-// src/hooks/on-save-intent.ts
-var ENABLED = process.env.CONTEXTSTREAM_SAVE_INTENT_ENABLED !== "false";
-var SAVE_PATTERNS = [
-  // Direct save requests
-  /\b(save|store|record|capture|log|document|write down|note down|keep track)\b.*\b(this|that|it|the)\b/i,
-  /\b(save|store|record|capture|log)\b.*\b(to|in|for)\b.*\b(contextstream|memory|later|reference|future)\b/i,
-  // Document creation
-  /\b(create|make|write|draft)\b.*\b(a|the)\b.*\b(document|doc|note|summary|report|spec|design)\b/i,
-  /\b(document|summarize|write up)\b.*\b(this|that|the|our)\b.*\b(decision|discussion|conversation|meeting|finding)\b/i,
-  // Memory/reference requests
-  /\b(remember|don't forget|keep in mind|note that|important to remember)\b/i,
-  /\bfor\s+(future|later)\s+reference\b/i,
-  /\b(add|put)\s+(this|it|that)\s+(to|in)\s+(memory|notes|docs)\b/i,
-  // Decision tracking
-  /\b(we\s+)?(decided|agreed|concluded|determined)\b.*\b(to|that)\b/i,
-  /\blet('s|s)\s+document\b/i,
-  /\bsave\s+(this|the)\s+(decision|choice|approach)\b/i,
-  // Implementation/design docs
-  /\b(implementation|design|architecture|spec)\s+(doc|document|plan)\b/i,
-  /\bwrite\s+(the|a|an)\s+.*(md|markdown|readme)\b/i
-];
-var LOCAL_FILE_PATTERNS = [
-  /\b(save|write|create)\s+(it|this|the\s+\w+)\s+(to|in|as)\s+[./~]/i,
-  /\b(save|write)\s+to\s+.*(\.md|\.txt|\.json|docs\/|notes\/)/i,
-  /\bcreate\s+(a|the)\s+file\b/i
-];
-function detectsSaveIntent(text) {
-  const hasSaveIntent = SAVE_PATTERNS.some((p) => p.test(text));
-  const isLocalFile = LOCAL_FILE_PATTERNS.some((p) => p.test(text));
-  return { hasSaveIntent, isLocalFile };
-}
-var SAVE_GUIDANCE = `[CONTEXTSTREAM DOCUMENT STORAGE]
-The user wants to save/store content. Use ContextStream instead of local files:
-
-**For decisions/notes:**
-\`\`\`
-mcp__contextstream__session(
-  action="capture",
-  event_type="decision|note|insight",
-  title="...",
-  content="...",
-  importance="high|medium|low"
-)
-\`\`\`
-
-**For documents/specs:**
-\`\`\`
-mcp__contextstream__docs(
-  action="create",
-  title="...",
-  content="...",
-  doc_type="implementation|design|spec|guide"
-)
-\`\`\`
-
-**For plans:**
-\`\`\`
-mcp__contextstream__session(
-  action="capture_plan",
-  title="...",
-  steps=[...]
-)
-\`\`\`
-
-**Why ContextStream?**
-- Persists across sessions (local files don't)
-- Searchable and retrievable
-- Shows up in context automatically
-- Can be shared with team
-
-Only save to local files if user explicitly requests a specific file path.
-[END GUIDANCE]`;
-async function runOnSaveIntentHook() {
-  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);
-  }
-  let prompt = input.prompt || "";
-  if (!prompt && input.session?.messages) {
-    for (const msg of [...input.session.messages].reverse()) {
-      if (msg.role === "user") {
-        if (typeof msg.content === "string") {
-          prompt = msg.content;
-        } else if (Array.isArray(msg.content)) {
-          for (const block of msg.content) {
-            if (block.type === "text" && block.text) {
-              prompt = block.text;
-              break;
-            }
-          }
-        }
-        break;
-      }
-    }
-  }
-  if (!prompt) {
-    process.exit(0);
-  }
-  const { hasSaveIntent, isLocalFile } = detectsSaveIntent(prompt);
-  if (hasSaveIntent || isLocalFile) {
-    console.log(
-      JSON.stringify({
-        hookSpecificOutput: {
-          hookEventName: "UserPromptSubmit",
-          additionalContext: SAVE_GUIDANCE
-        }
-      })
-    );
-  }
-  process.exit(0);
-}
-var isDirectRun = process.argv[1]?.includes("on-save-intent") || process.argv[2] === "on-save-intent";
-if (isDirectRun) {
-  runOnSaveIntentHook().catch(() => process.exit(0));
-}
-export {
-  runOnSaveIntentHook
-};

package/dist/hooks/on-task.js

@@ -1,139 +0,0 @@
-#!/usr/bin/env node
-
-// src/hooks/on-task.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { homedir } from "node:os";
-var ENABLED = process.env.CONTEXTSTREAM_TASK_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 captureTaskInvocation(description, prompt, agentType, result, sessionId) {
-  if (!API_KEY) return;
-  const payload = {
-    event_type: "task_agent",
-    title: `Agent: ${agentType} - ${description}`,
-    content: JSON.stringify({
-      description,
-      prompt: prompt.slice(0, 1e3),
-      agent_type: agentType,
-      result: result.slice(0, 2e3),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }),
-    importance: "medium",
-    tags: ["task", "agent", agentType.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 runOnTaskHook() {
-  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 !== "Task") {
-    process.exit(0);
-  }
-  const cwd = input.cwd || process.cwd();
-  loadConfigFromMcpJson(cwd);
-  const description = input.tool_input?.description || "Unknown task";
-  const prompt = input.tool_input?.prompt || "";
-  const agentType = input.tool_input?.subagent_type || "general-purpose";
-  const result = input.tool_result?.output || "";
-  const sessionId = input.session_id || "unknown";
-  captureTaskInvocation(description, prompt, agentType, result, sessionId).catch(() => {
-  });
-  process.exit(0);
-}
-var isDirectRun = process.argv[1]?.includes("on-task") || process.argv[2] === "on-task";
-if (isDirectRun) {
-  runOnTaskHook().catch(() => process.exit(0));
-}
-export {
-  runOnTaskHook
-};