@contextstream/mcp-server 0.4.63 → 0.4.64

package/dist/hooks/subagent-stop.js

@@ -0,0 +1,298 @@
+#!/usr/bin/env node
+
+// src/hooks/subagent-stop.ts
+import * as fs2 from "node:fs";
+
+// 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()
+      }
+    }
+  });
+}
+async function createPlan(config, title, description) {
+  if (!isConfigured(config) || !config.workspaceId) return null;
+  try {
+    const result = await apiRequest(config, "/plans", {
+      method: "POST",
+      body: {
+        workspace_id: config.workspaceId,
+        project_id: config.projectId || void 0,
+        title,
+        description
+      }
+    });
+    return typeof result?.id === "string" ? result.id : null;
+  } catch {
+    return null;
+  }
+}
+async function createTask(config, params) {
+  if (!isConfigured(config) || !config.workspaceId) return null;
+  try {
+    const result = await apiRequest(config, "/tasks", {
+      method: "POST",
+      body: {
+        workspace_id: config.workspaceId,
+        project_id: config.projectId || void 0,
+        title: params.title,
+        description: params.description,
+        plan_id: params.planId || void 0,
+        status: params.status
+      }
+    });
+    return typeof result?.id === "string" ? result.id : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks/subagent-stop.ts
+function parseTranscript(transcriptPath) {
+  try {
+    const content = fs2.readFileSync(transcriptPath, "utf8");
+    const assistantMessages = [];
+    let toolCallCount = 0;
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.trim();
+      if (!line) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type === "tool_use") {
+        toolCallCount += 1;
+      }
+      const isAssistant = entry.type === "assistant" || entry.role === "assistant" || Array.isArray(entry.content) && entry.role === "assistant";
+      if (!isAssistant) continue;
+      const contentValue = entry.content;
+      if (typeof contentValue === "string" && contentValue.trim()) {
+        assistantMessages.push(contentValue.trim());
+      } else if (Array.isArray(contentValue)) {
+        const text = contentValue.map((item) => typeof item?.text === "string" ? item.text : typeof item === "string" ? item : "").filter(Boolean).join("\n").trim();
+        if (text) assistantMessages.push(text);
+      }
+    }
+    return { assistantMessages, toolCallCount };
+  } catch {
+    return { assistantMessages: [], toolCallCount: 0 };
+  }
+}
+function derivePlanTitle(summary, agentId) {
+  for (const line of summary.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) {
+      return trimmed.replace(/^#+\s*/, "").slice(0, 120);
+    }
+    if (trimmed) return trimmed.slice(0, 120);
+  }
+  return `Plan generated by ${agentId}`;
+}
+function extractPlanTasks(summary) {
+  const tasks = [];
+  for (const line of summary.split("\n")) {
+    const trimmed = line.trim();
+    if (/^[-*]\s+/.test(trimmed) || /^\d+\.\s+/.test(trimmed)) {
+      const task = trimmed.replace(/^([-*]|\d+\.)\s+/, "").trim();
+      if (task) tasks.push(task);
+    }
+  }
+  return Array.from(new Set(tasks)).slice(0, 20);
+}
+async function runSubagentStopHook() {
+  const input = readHookInput();
+  const cwd = extractCwd(input);
+  const config = loadHookConfig(cwd);
+  if (!isConfigured(config)) {
+    writeHookOutput();
+    return;
+  }
+  const agentType = typeof input.agent_type === "string" && input.agent_type || typeof input.subagent_type === "string" && input.subagent_type || "unknown";
+  const agentId = typeof input.agent_id === "string" && input.agent_id || "unknown";
+  const transcriptPath = typeof input.agent_transcript_path === "string" && input.agent_transcript_path || typeof input.transcript_path === "string" && input.transcript_path || "";
+  const transcript = transcriptPath && fs2.existsSync(transcriptPath) ? parseTranscript(transcriptPath) : { assistantMessages: [], toolCallCount: 0 };
+  const summaryText = transcript.assistantMessages.join("\n\n") || typeof input.summary === "string" && input.summary || "(No assistant output found in subagent transcript.)";
+  if (agentType.toLowerCase() === "plan") {
+    const suppliedPlanId = typeof input.plan_id === "string" && input.plan_id || typeof input.planId === "string" && input.planId || null;
+    const planTitle = derivePlanTitle(summaryText, agentId);
+    const planId = suppliedPlanId || await createPlan(config, planTitle, summaryText.slice(0, 12e3));
+    const tasks = extractPlanTasks(summaryText);
+    let createdTaskCount = 0;
+    if (planId) {
+      for (const task of tasks) {
+        const created = await createTask(config, {
+          title: task,
+          planId,
+          status: "pending"
+        });
+        if (created) createdTaskCount += 1;
+      }
+    }
+    await postMemoryEvent(
+      config,
+      "Plan subagent captured",
+      {
+        agent_type: "Plan",
+        agent_id: agentId,
+        plan_title: planTitle,
+        plan_id: planId,
+        supplied_plan_id: suppliedPlanId,
+        extracted_task_count: tasks.length,
+        created_task_count: createdTaskCount,
+        assistant_message_count: transcript.assistantMessages.length,
+        tool_call_count: transcript.toolCallCount,
+        summary_preview: summaryText.slice(0, 2e3),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ["hook", "subagent_stop", "plan"]
+    ).catch(() => {
+    });
+  } else {
+    await postMemoryEvent(
+      config,
+      `Subagent finished: ${agentType}`,
+      {
+        agent_type: agentType,
+        agent_id: agentId,
+        summary: summaryText.slice(0, 4e3),
+        assistant_message_count: transcript.assistantMessages.length,
+        tool_call_count: transcript.toolCallCount,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ["hook", "subagent_stop", agentType]
+    ).catch(() => {
+    });
+  }
+  writeHookOutput();
+}
+var isDirectRun = process.argv[1]?.includes("subagent-stop") || process.argv[2] === "subagent-stop";
+if (isDirectRun) {
+  runSubagentStopHook().catch(() => process.exit(0));
+}
+export {
+  runSubagentStopHook
+};

package/dist/hooks/task-completed.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+// 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()
+      }
+    }
+  });
+}
+async function createTask(config, params) {
+  if (!isConfigured(config) || !config.workspaceId) return null;
+  try {
+    const result = await apiRequest(config, "/tasks", {
+      method: "POST",
+      body: {
+        workspace_id: config.workspaceId,
+        project_id: config.projectId || void 0,
+        title: params.title,
+        description: params.description,
+        plan_id: params.planId || void 0,
+        status: params.status
+      }
+    });
+    return typeof result?.id === "string" ? result.id : null;
+  } catch {
+    return null;
+  }
+}
+async function updateTaskStatus(config, taskId, status, title, description) {
+  if (!isConfigured(config) || !taskId) return false;
+  try {
+    await apiRequest(config, `/tasks/${taskId}`, {
+      method: "PATCH",
+      body: {
+        status,
+        ...title ? { title } : {},
+        ...description ? { description } : {}
+      }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/task-completed.ts
+function firstString(input, keys) {
+  for (const key of keys) {
+    const value = input[key];
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  const task = input.task;
+  if (task && typeof task === "object") {
+    return firstString(task, keys);
+  }
+  return void 0;
+}
+function looksLikeRecoveryTask(description) {
+  const lower = description.toLowerCase();
+  return ["error", "failure", "retry", "recover", "fix", "incident"].some(
+    (keyword) => lower.includes(keyword)
+  );
+}
+async function runTaskCompletedHook() {
+  const input = readHookInput();
+  const cwd = extractCwd(input);
+  const config = loadHookConfig(cwd);
+  const taskId = firstString(input, ["task_id", "taskId"]) || "";
+  const taskSubject = firstString(input, ["task_subject", "task_title", "title", "subject", "description"]) || "Completed task";
+  const taskDescription = firstString(input, ["task_description", "details", "content"]);
+  const planId = firstString(input, ["plan_id", "planId"]);
+  if (process.env.CONTEXTSTREAM_TASK_COMPLETED_REQUIRE_SUBJECT === "true" && !taskSubject.trim()) {
+    writeHookOutput({ blocked: true, reason: "TaskCompleted requires a non-empty task subject" });
+    return;
+  }
+  if (isConfigured(config)) {
+    let updated = false;
+    if (taskId) {
+      updated = await updateTaskStatus(
+        config,
+        taskId,
+        "completed",
+        taskSubject,
+        taskDescription
+      );
+    }
+    if (!updated) {
+      await createTask(config, {
+        title: taskSubject,
+        description: taskDescription,
+        planId: planId || void 0,
+        status: "completed"
+      });
+    }
+    await postMemoryEvent(
+      config,
+      "Task completed",
+      {
+        task_id: taskId || null,
+        title: taskSubject,
+        description: taskDescription,
+        plan_id: planId || null,
+        agent_id: firstString(input, ["agent_id", "agentId"]) || null,
+        team_name: firstString(input, ["team_name", "teamName"]) || null,
+        completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        source: "task_completed_hook"
+      },
+      ["hook", "task", "completed"],
+      "task"
+    ).catch(() => {
+    });
+    if (taskDescription && looksLikeRecoveryTask(taskDescription)) {
+      await postMemoryEvent(
+        config,
+        "Lesson from task completion",
+        {
+          task: taskSubject,
+          description: taskDescription,
+          lesson: "Recovered from an execution issue; consider codifying this into tests/guards."
+        },
+        ["hook", "lesson", "task_completed"],
+        "lesson"
+      ).catch(() => {
+      });
+    }
+  }
+  writeHookOutput();
+}
+var isDirectRun = process.argv[1]?.includes("task-completed") || process.argv[2] === "task-completed";
+if (isDirectRun) {
+  runTaskCompletedHook().catch(() => process.exit(0));
+}
+export {
+  runTaskCompletedHook
+};