@contextstream/mcp-server 0.3.26 → 0.3.28

package/dist/index.js

@@ -6282,6 +6282,191 @@ W:${wsHint}
     }
     return matches / keywords.length;
   }
+  // ============================================
+  // Slack Integration Methods
+  // ============================================
+  /**
+   * Get Slack integration statistics and overview
+   */
+  async slackStats(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack stats");
+    }
+    const query = new URLSearchParams();
+    if (params?.days) query.set("days", String(params.days));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/stats${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get Slack users for a workspace
+   */
+  async slackUsers(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack users");
+    }
+    const query = new URLSearchParams();
+    if (params?.page) query.set("page", String(params.page));
+    if (params?.per_page) query.set("per_page", String(params.per_page));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/users${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get Slack channels with stats
+   */
+  async slackChannels(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack channels");
+    }
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/channels`, { method: "GET" });
+  }
+  /**
+   * Get recent Slack activity feed
+   */
+  async slackActivity(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack activity");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.channel_id) query.set("channel_id", params.channel_id);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/activity${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get high-engagement Slack discussions
+   */
+  async slackDiscussions(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack discussions");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/discussions${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get top Slack contributors
+   */
+  async slackContributors(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack contributors");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/contributors${suffix}`, { method: "GET" });
+  }
+  /**
+   * Trigger a sync of Slack user profiles
+   */
+  async slackSyncUsers(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for syncing Slack users");
+    }
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/sync-users`, { method: "POST" });
+  }
+  /**
+   * Search Slack messages
+   */
+  async slackSearch(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for Slack search");
+    }
+    const query = new URLSearchParams();
+    query.set("q", params.q);
+    if (params?.limit) query.set("limit", String(params.limit));
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/slack/search?${query.toString()}`, { method: "GET" });
+  }
+  // ============================================
+  // GitHub Integration Methods
+  // ============================================
+  /**
+   * Get GitHub integration statistics and overview
+   */
+  async githubStats(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub stats");
+    }
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/stats`, { method: "GET" });
+  }
+  /**
+   * Get GitHub repository stats
+   */
+  async githubRepos(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub repos");
+    }
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/repos`, { method: "GET" });
+  }
+  /**
+   * Get recent GitHub activity feed
+   */
+  async githubActivity(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub activity");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.repo) query.set("repo", params.repo);
+    if (params?.type) query.set("type", params.type);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/activity${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get GitHub issues and PRs
+   */
+  async githubIssues(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub issues");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    if (params?.offset) query.set("offset", String(params.offset));
+    if (params?.state) query.set("state", params.state);
+    if (params?.repo) query.set("repo", params.repo);
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/issues${suffix}`, { method: "GET" });
+  }
+  /**
+   * Get top GitHub contributors
+   */
+  async githubContributors(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub contributors");
+    }
+    const query = new URLSearchParams();
+    if (params?.limit) query.set("limit", String(params.limit));
+    const suffix = query.toString() ? `?${query.toString()}` : "";
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/contributors${suffix}`, { method: "GET" });
+  }
+  /**
+   * Search GitHub content
+   */
+  async githubSearch(params) {
+    const withDefaults = this.withDefaults(params || {});
+    if (!withDefaults.workspace_id) {
+      throw new Error("workspace_id is required for GitHub search");
+    }
+    const query = new URLSearchParams();
+    query.set("q", params.q);
+    if (params?.limit) query.set("limit", String(params.limit));
+    return request(this.config, `/workspaces/${withDefaults.workspace_id}/github/search?${query.toString()}`, { method: "GET" });
+  }
 };
 
 // src/rules-templates.ts
@@ -6529,7 +6714,7 @@ function toStructured(data) {
   return void 0;
 }
 function registerTools(server, client, sessionManager) {
-  const upgradeUrl2 = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
+  const upgradeUrl = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
     "ai_context",
@@ -6537,7 +6722,22 @@ function registerTools(server, client, sessionManager) {
     "ai_context_budget",
     "ai_embeddings",
     "ai_plan",
-    "ai_tasks"
+    "ai_tasks",
+    // Slack integration tools
+    "slack_stats",
+    "slack_channels",
+    "slack_contributors",
+    "slack_activity",
+    "slack_discussions",
+    "slack_search",
+    "slack_sync_users",
+    // GitHub integration tools
+    "github_stats",
+    "github_repos",
+    "github_contributors",
+    "github_activity",
+    "github_issues",
+    "github_search"
   ]);
   const proTools = (() => {
     const raw = process.env.CONTEXTSTREAM_PRO_TOOLS;
@@ -6558,7 +6758,7 @@ function registerTools(server, client, sessionManager) {
     return errorResult(
       [
         `Access denied: \`${toolName}\` requires ContextStream PRO.`,
-        `Upgrade: ${upgradeUrl2}`
+        `Upgrade: ${upgradeUrl}`
       ].join("\n")
     );
   }
@@ -6596,7 +6796,7 @@ function registerTools(server, client, sessionManager) {
       title: `${config.title} (${accessLabel})`,
       description: `${config.description}
 
-Access: ${accessLabel}${accessLabel === "PRO" ? ` (upgrade: ${upgradeUrl2})` : ""}`
+Access: ${accessLabel}${accessLabel === "PRO" ? ` (upgrade: ${upgradeUrl})` : ""}`
     };
     const safeHandler = async (input) => {
       try {
@@ -6609,7 +6809,7 @@ Access: ${accessLabel}${accessLabel === "PRO" ? ` (upgrade: ${upgradeUrl2})` : "
         const errorCode = error?.code || error?.status || "UNKNOWN_ERROR";
         const isPlanLimit = String(errorCode).toUpperCase() === "FORBIDDEN" && String(errorMessage).toLowerCase().includes("plan limit reached");
         const upgradeHint = isPlanLimit ? `
-Upgrade: ${upgradeUrl2}` : "";
+Upgrade: ${upgradeUrl}` : "";
         const serializedError = new Error(
           `[${errorCode}] ${errorMessage}${upgradeHint}${errorDetails ? `: ${JSON.stringify(errorDetails)}` : ""}`
         );
@@ -8510,764 +8710,345 @@ This saves ~80% tokens compared to including full chat history.`,
       };
     }
   );
-}
-
-// src/resources.ts
-import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
-function wrapText(uri, text) {
-  return { contents: [{ uri, text }] };
-}
-function registerResources(server, client, apiUrl) {
-  server.registerResource(
-    "contextstream-openapi",
-    new ResourceTemplate("contextstream:openapi", { list: void 0 }),
+  registerTool(
+    "slack_stats",
     {
-      title: "ContextStream OpenAPI spec",
-      description: "Machine-readable OpenAPI from the configured API endpoint",
-      mimeType: "application/json"
+      title: "Slack overview stats",
+      description: `Get Slack integration statistics and overview for a workspace.
+Returns: total messages, threads, active users, channel stats, activity trends, and sync status.
+Use this to understand Slack activity and engagement patterns.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        days: external_exports.number().optional().describe("Number of days to include in stats (default: 30)")
+      })
     },
-    async () => {
-      const uri = `${apiUrl.replace(/\/$/, "")}/api-docs/openapi.json`;
-      const res = await fetch(uri);
-      const text = await res.text();
-      return wrapText("contextstream:openapi", text);
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackStats({ workspace_id: workspaceId, days: input.days });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
-  server.registerResource(
-    "contextstream-workspaces",
-    new ResourceTemplate("contextstream:workspaces", { list: void 0 }),
-    { title: "Workspaces", description: "List of accessible workspaces" },
-    async () => {
-      const data = await client.listWorkspaces();
-      return wrapText("contextstream:workspaces", JSON.stringify(data, null, 2));
+  registerTool(
+    "slack_channels",
+    {
+      title: "List Slack channels",
+      description: `Get synced Slack channels with statistics for a workspace.
+Returns: channel names, message counts, thread counts, and last activity timestamps.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional()
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackChannels({ workspace_id: workspaceId });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
-  server.registerResource(
-    "contextstream-projects",
-    new ResourceTemplate("contextstream:projects/{workspaceId}", { list: void 0 }),
-    { title: "Projects for workspace", description: "Projects in the specified workspace" },
-    async (uri, { workspaceId }) => {
-      const wsId = Array.isArray(workspaceId) ? workspaceId[0] : workspaceId;
-      const data = await client.listProjects({ workspace_id: wsId });
-      return wrapText(uri.href, JSON.stringify(data, null, 2));
+  registerTool(
+    "slack_contributors",
+    {
+      title: "Slack top contributors",
+      description: `Get top Slack contributors for a workspace.
+Returns: user profiles with message counts, sorted by activity level.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum contributors to return (default: 20)")
+      })
+    },
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackContributors({ workspace_id: workspaceId, limit: input.limit });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
-}
-
-// src/prompts.ts
-var ID_NOTES = [
-  "Notes:",
-  "- If ContextStream is not initialized in this conversation, call `session_init` first (omit ids).",
-  "- Do not ask me for `workspace_id`/`project_id` \u2014 use session defaults or IDs returned by `session_init`.",
-  "- Prefer omitting IDs in tool calls when the tool supports defaults."
-];
-var upgradeUrl = process.env.CONTEXTSTREAM_UPGRADE_URL || "https://contextstream.io/pricing";
-var proPrompts = /* @__PURE__ */ new Set([
-  "build-context",
-  "generate-plan",
-  "generate-tasks",
-  "token-budget-context"
-]);
-function promptAccessLabel(promptName) {
-  return proPrompts.has(promptName) ? "PRO" : "Free";
-}
-function registerPrompts(server) {
-  server.registerPrompt(
-    "explore-codebase",
+  registerTool(
+    "slack_activity",
     {
-      title: `Explore Codebase (${promptAccessLabel("explore-codebase")})`,
-      description: "Get an overview of a project codebase structure and key components"
+      title: "Slack activity feed",
+      description: `Get recent Slack activity feed for a workspace.
+Returns: messages with user info, reactions, replies, and timestamps.
+Can filter by channel.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum messages to return (default: 50)"),
+        offset: external_exports.number().optional().describe("Pagination offset"),
+        channel_id: external_exports.string().optional().describe("Filter by specific channel ID")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "I want to understand the current codebase.",
-              "",
-              ...ID_NOTES,
-              "",
-              "Please help me by:",
-              "1. Use `projects_overview` to get a project summary (use session defaults; only pass `project_id` if required).",
-              "2. Use `projects_files` to identify key entry points.",
-              "3. If a focus area is clear from our conversation, prioritize it; otherwise ask me what to focus on.",
-              "4. Use `search_semantic` (and optionally `search_hybrid`) to find the most relevant files.",
-              "5. Summarize the architecture, major modules, and where to start editing."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackActivity({
+        workspace_id: workspaceId,
+        limit: input.limit,
+        offset: input.offset,
+        channel_id: input.channel_id
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "capture-decision",
+  registerTool(
+    "slack_discussions",
     {
-      title: `Capture Decision (${promptAccessLabel("capture-decision")})`,
-      description: "Document an architectural or technical decision in workspace memory"
+      title: "Slack key discussions",
+      description: `Get high-engagement Slack discussions/threads for a workspace.
+Returns: threads with high reply/reaction counts, sorted by engagement.
+Useful for finding important conversations and decisions.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum discussions to return (default: 20)")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Please capture an architectural/technical decision in ContextStream memory.",
-              "",
-              ...ID_NOTES,
-              "",
-              "Instructions:",
-              "- If the decision is already described in this conversation, extract: title, context, decision, consequences/tradeoffs.",
-              "- If anything is missing, ask me 1\u20133 quick questions to fill the gaps.",
-              "- Then call `session_capture` with:",
-              '  - event_type: "decision"',
-              "  - title: (short ADR title)",
-              "  - content: a well-formatted ADR (Context, Decision, Consequences)",
-              '  - tags: include relevant tags (e.g., "adr", "architecture")',
-              '  - importance: "high"',
-              "",
-              "After capturing, confirm what was saved."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackDiscussions({ workspace_id: workspaceId, limit: input.limit });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "review-context",
+  registerTool(
+    "slack_search",
     {
-      title: `Code Review Context (${promptAccessLabel("review-context")})`,
-      description: "Build context for reviewing code changes"
+      title: "Search Slack messages",
+      description: `Search Slack messages for a workspace.
+Returns: matching messages with channel, user, and engagement info.
+Use this to find specific conversations or topics.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        q: external_exports.string().describe("Search query"),
+        limit: external_exports.number().optional().describe("Maximum results (default: 50)")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "I need context to review a set of code changes.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If file paths and a short change description are not already in this conversation, ask me for them.",
-              "",
-              "Then build review context by:",
-              "1. Using `graph_dependencies` to find what depends on the changed areas.",
-              "2. Using `graph_impact` to assess potential blast radius.",
-              "3. Using `memory_search` to find related decisions/notes.",
-              "4. Using `search_semantic` to find related code patterns.",
-              "",
-              "Provide:",
-              "- What the files/components do",
-              "- What might be affected",
-              "- Relevant prior decisions/lessons",
-              "- Review checklist + risks to focus on"
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackSearch({ workspace_id: workspaceId, q: input.q, limit: input.limit });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "investigate-bug",
+  registerTool(
+    "slack_sync_users",
     {
-      title: `Investigate Bug (${promptAccessLabel("investigate-bug")})`,
-      description: "Build context for debugging an issue"
+      title: "Sync Slack users",
+      description: `Trigger a sync of Slack user profiles for a workspace.
+This fetches the latest user info from Slack and updates local profiles.
+Also auto-maps Slack users to ContextStream users by email.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional()
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "I want help investigating a bug.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If the error/symptom is not already stated, ask me for the exact error message and what I expected vs what happened.",
-              "- If an affected area/component is not known, ask me where I noticed it.",
-              "",
-              "Then:",
-              "1. Use `search_semantic` to find code related to the error/symptom.",
-              "2. Use `search_pattern` to locate where similar errors are thrown or logged.",
-              "3. If you identify key functions, use `graph_call_path` to trace call flows.",
-              "4. Use `memory_search` to check if we have prior notes/bugs about this area.",
-              "",
-              "Return:",
-              "- Likely origin locations",
-              "- Call flow (if found)",
-              "- Related past context",
-              "- Suggested debugging steps"
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "explore-knowledge",
-    {
-      title: `Explore Knowledge Graph (${promptAccessLabel("explore-knowledge")})`,
-      description: "Navigate and understand the knowledge graph for a workspace"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Help me explore the knowledge captured in this workspace.",
-              "",
-              ...ID_NOTES,
-              "",
-              "Approach:",
-              "1. Use `memory_summary` for a high-level overview.",
-              "2. Use `memory_decisions` to see decision history (titles + a few key details).",
-              "3. Use `memory_list_nodes` to see available knowledge nodes.",
-              "4. If a starting topic is clear from the conversation, use `memory_search` for it.",
-              "5. Use `graph_related` on the most relevant nodes to expand connections.",
-              "",
-              "Provide:",
-              "- Key themes and topics",
-              "- Important decisions + rationale",
-              "- Suggested \u201Cnext nodes\u201D to explore"
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "onboard-to-project",
-    {
-      title: `Project Onboarding (${promptAccessLabel("onboard-to-project")})`,
-      description: "Generate onboarding context for a new team member"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Create an onboarding guide for a new team member joining this project.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If the role is not specified, ask me what role they are onboarding into (backend, frontend, fullstack, etc.).",
-              "",
-              "Gather context:",
-              "1. Use `projects_overview` and `projects_statistics` for project summary.",
-              "2. Use `projects_files` to identify key entry points.",
-              "3. Use `memory_timeline` and `memory_decisions` to understand recent changes and architectural choices.",
-              "4. Use `search_semantic` to find READMEs/docs/setup instructions.",
-              "",
-              "Output:",
-              "- Project overview and purpose",
-              "- Tech stack + architecture map",
-              "- Key files/entry points relevant to the role",
-              "- Important decisions + rationale",
-              "- Recent changes/current focus",
-              "- Step-by-step getting started"
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "analyze-refactoring",
-    {
-      title: `Refactoring Analysis (${promptAccessLabel("analyze-refactoring")})`,
-      description: "Analyze a codebase for refactoring opportunities"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Analyze the codebase for refactoring opportunities.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If a target area is obvious from our conversation, focus there; otherwise ask me what area to analyze.",
-              "",
-              "Please investigate:",
-              "1. `graph_circular_dependencies` (circular deps to break)",
-              "2. `graph_unused_code` (dead code to remove)",
-              "3. `search_pattern` (duplication patterns)",
-              "4. `projects_statistics` (high complexity hotspots)",
-              "",
-              "Provide a prioritized list with quick wins vs deeper refactors."
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "build-context",
-    {
-      title: `Build LLM Context (${promptAccessLabel("build-context")})`,
-      description: "Build comprehensive context for an LLM task"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Build comprehensive context for the task we are working on.",
-              "",
-              `Access: ${promptAccessLabel("build-context")}${promptAccessLabel("build-context") === "PRO" ? ` (upgrade: ${upgradeUrl})` : ""}`,
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If the \u201Cquery\u201D is clear from the latest user request, use that.",
-              "- Otherwise ask me: \u201CWhat do you need context for?\u201D",
-              "",
-              "Then:",
-              "- Call `ai_enhanced_context` with include_code=true, include_docs=true, include_memory=true (omit IDs unless required).",
-              "- Synthesize the returned context into a short briefing with links/file paths and key decisions/risks."
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "smart-search",
-    {
-      title: `Smart Search (${promptAccessLabel("smart-search")})`,
-      description: "Search across memory, decisions, and code for a query"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Find the most relevant context for what I am asking about.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If a query is clear from the conversation, use it.",
-              "- Otherwise ask me what I want to find.",
-              "",
-              "Then:",
-              "1. Use `session_smart_search` for the query.",
-              "2. If results are thin, follow up with `search_hybrid` and `memory_search`.",
-              "3. Return the top results with file paths/links and a short synthesis."
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "recall-context",
-    {
-      title: `Recall Context (${promptAccessLabel("recall-context")})`,
-      description: "Retrieve relevant past decisions and memory for a query"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Recall relevant past context (decisions, notes, lessons) for what I am asking about.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If a recall query is clear from the conversation, use it.",
-              "- Otherwise ask me what topic I want to recall.",
-              "",
-              "Then:",
-              "- Use `session_recall` with the query (omit IDs unless required).",
-              "- Summarize the key points and any relevant decisions/lessons."
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "session-summary",
-    {
-      title: `Session Summary (${promptAccessLabel("session-summary")})`,
-      description: "Get a compact summary of workspace/project context"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Generate a compact, token-efficient summary of the current workspace/project context.",
-              "",
-              ...ID_NOTES,
-              "",
-              "Use `session_summary` (default max_tokens=500 unless I specify otherwise).",
-              "Then list:",
-              "- Top decisions (titles only)",
-              "- Any high-priority lessons to watch for"
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "capture-lesson",
-    {
-      title: `Capture Lesson (${promptAccessLabel("capture-lesson")})`,
-      description: "Record a lesson learned from an error or correction"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Capture a lesson learned so it is surfaced in future sessions.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If the lesson details are not fully present in the conversation, ask me for:",
-              "- title (what to remember)",
-              "- severity (low|medium|high|critical, default medium)",
-              "- category (workflow|code_quality|verification|communication|project_specific)",
-              "- trigger (what caused it)",
-              "- impact (what went wrong)",
-              "- prevention (how to prevent it)",
-              "- keywords (optional)",
-              "",
-              "Then call `session_capture_lesson` with those fields and confirm it was saved."
-            ].join("\n")
-          }
-        }
-      ]
-    })
-  );
-  server.registerPrompt(
-    "capture-preference",
-    {
-      title: `Capture Preference (${promptAccessLabel("capture-preference")})`,
-      description: "Save a user preference to memory"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Save a user preference to ContextStream memory.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If the preference is not explicit in the conversation, ask me what to remember.",
-              "",
-              "Then call `session_capture` with:",
-              '- event_type: "preference"',
-              "- title: (short title)",
-              "- content: (preference text)",
-              '- importance: "medium"'
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.slackSyncUsers({ workspace_id: workspaceId });
+      return {
+        content: [{
+          type: "text",
+          text: `\u2705 Synced ${result.synced_users} Slack users, auto-mapped ${result.auto_mapped} by email.`
+        }],
+        structuredContent: toStructured(result)
+      };
+    }
   );
-  server.registerPrompt(
-    "capture-task",
+  registerTool(
+    "github_stats",
     {
-      title: `Capture Task (${promptAccessLabel("capture-task")})`,
-      description: "Capture an action item into memory"
+      title: "GitHub overview stats",
+      description: `Get GitHub integration statistics and overview for a workspace.
+Returns: total issues, PRs, releases, comments, repository stats, activity trends, and sync status.
+Use this to understand GitHub activity and engagement patterns across synced repositories.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional()
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Capture an action item into ContextStream memory.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If the task is not explicit in the conversation, ask me what to capture.",
-              "",
-              "Then call `session_capture` with:",
-              '- event_type: "task"',
-              "- title: (short title)",
-              "- content: (task details)",
-              '- importance: "medium"'
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubStats({ workspace_id: workspaceId });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "capture-bug",
+  registerTool(
+    "github_repos",
     {
-      title: `Capture Bug (${promptAccessLabel("capture-bug")})`,
-      description: "Capture a bug report into workspace memory"
+      title: "List GitHub repositories",
+      description: `Get synced GitHub repositories with statistics for a workspace.
+Returns: repository names with issue, PR, release, and comment counts, plus last activity timestamps.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional()
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Capture a bug report in ContextStream memory.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If details are missing, ask me for:",
-              "- title",
-              "- description",
-              "- steps to reproduce (optional)",
-              "- expected behavior (optional)",
-              "- actual behavior (optional)",
-              "",
-              "Then call `session_capture` with:",
-              '- event_type: "bug"',
-              "- title: (bug title)",
-              "- content: a well-formatted bug report (include all provided details)",
-              "- tags: component/area tags",
-              '- importance: "high"'
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubRepos({ workspace_id: workspaceId });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "capture-feature",
+  registerTool(
+    "github_contributors",
     {
-      title: `Capture Feature (${promptAccessLabel("capture-feature")})`,
-      description: "Capture a feature request into workspace memory"
+      title: "GitHub top contributors",
+      description: `Get top GitHub contributors for a workspace.
+Returns: usernames with contribution counts, sorted by activity level.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum contributors to return (default: 20)")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Capture a feature request in ContextStream memory.",
-              "",
-              ...ID_NOTES,
-              "",
-              "If details are missing, ask me for:",
-              "- title",
-              "- description",
-              "- rationale (optional)",
-              "- acceptance criteria (optional)",
-              "",
-              "Then call `session_capture` with:",
-              '- event_type: "feature"',
-              "- title: (feature title)",
-              "- content: a well-formatted feature request",
-              "- tags: component/area tags",
-              '- importance: "medium"'
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubContributors({ workspace_id: workspaceId, limit: input.limit });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "generate-plan",
+  registerTool(
+    "github_activity",
     {
-      title: `Generate Plan (${promptAccessLabel("generate-plan")})`,
-      description: "Generate a development plan from a description"
+      title: "GitHub activity feed",
+      description: `Get recent GitHub activity feed for a workspace.
+Returns: issues, PRs, releases, and comments with details like state, author, labels.
+Can filter by repository or type (issue, pull_request, release, comment).`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum items to return (default: 50)"),
+        offset: external_exports.number().optional().describe("Pagination offset"),
+        repo: external_exports.string().optional().describe("Filter by repository name"),
+        type: external_exports.enum(["issue", "pull_request", "release", "comment"]).optional().describe("Filter by item type")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Generate a development plan for what I am trying to build/fix.",
-              "",
-              `Access: ${promptAccessLabel("generate-plan")}${promptAccessLabel("generate-plan") === "PRO" ? ` (upgrade: ${upgradeUrl})` : ""}`,
-              "",
-              ...ID_NOTES,
-              "",
-              "Use the most recent user request as the plan description. If unclear, ask me for a one-paragraph description.",
-              "",
-              "Then call `ai_plan` and present the plan as an ordered list with milestones and risks."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubActivity({
+        workspace_id: workspaceId,
+        limit: input.limit,
+        offset: input.offset,
+        repo: input.repo,
+        type: input.type
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "generate-tasks",
+  registerTool(
+    "github_issues",
     {
-      title: `Generate Tasks (${promptAccessLabel("generate-tasks")})`,
-      description: "Generate actionable tasks from a plan or description"
+      title: "GitHub issues and PRs",
+      description: `Get GitHub issues and pull requests for a workspace.
+Returns: issues/PRs with title, state, author, labels, comment count.
+Can filter by state (open/closed) or repository.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        limit: external_exports.number().optional().describe("Maximum items to return (default: 50)"),
+        offset: external_exports.number().optional().describe("Pagination offset"),
+        state: external_exports.enum(["open", "closed"]).optional().describe("Filter by state"),
+        repo: external_exports.string().optional().describe("Filter by repository name")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Generate actionable tasks for the work we are discussing.",
-              "",
-              `Access: ${promptAccessLabel("generate-tasks")}${promptAccessLabel("generate-tasks") === "PRO" ? ` (upgrade: ${upgradeUrl})` : ""}`,
-              "",
-              ...ID_NOTES,
-              "",
-              "If a plan_id exists in the conversation, use it. Otherwise use the latest user request as the description.",
-              "If granularity is not specified, default to medium.",
-              "",
-              "Call `ai_tasks` and return a checklist of tasks with acceptance criteria for each."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubIssues({
+        workspace_id: workspaceId,
+        limit: input.limit,
+        offset: input.offset,
+        state: input.state,
+        repo: input.repo
+      });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "token-budget-context",
+  registerTool(
+    "github_search",
     {
-      title: `Token-Budget Context (${promptAccessLabel("token-budget-context")})`,
-      description: "Get the most relevant context that fits within a token budget"
+      title: "Search GitHub content",
+      description: `Search GitHub issues, PRs, and comments for a workspace.
+Returns: matching items with repository, title, state, and content preview.
+Use this to find specific issues, PRs, or discussions.`,
+      inputSchema: external_exports.object({
+        workspace_id: external_exports.string().uuid().optional(),
+        q: external_exports.string().describe("Search query"),
+        limit: external_exports.number().optional().describe("Maximum results (default: 50)")
+      })
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Build the most relevant context that fits within a token budget.",
-              "",
-              `Access: ${promptAccessLabel("token-budget-context")}${promptAccessLabel("token-budget-context") === "PRO" ? ` (upgrade: ${upgradeUrl})` : ""}`,
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If a query is clear from the conversation, use it; otherwise ask me for a query.",
-              "- If max_tokens is not specified, ask me for a token budget (e.g., 500/1000/2000).",
-              "",
-              "Then call `ai_context_budget` and return the packed context plus a short note about what was included/excluded."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async (input) => {
+      const workspaceId = resolveWorkspaceId(input.workspace_id);
+      if (!workspaceId) {
+        return errorResult("Error: workspace_id is required. Please call session_init first or provide workspace_id explicitly.");
+      }
+      const result = await client.githubSearch({ workspace_id: workspaceId, q: input.q, limit: input.limit });
+      return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
+    }
   );
-  server.registerPrompt(
-    "find-todos",
+}
+
+// src/resources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function wrapText(uri, text) {
+  return { contents: [{ uri, text }] };
+}
+function registerResources(server, client, apiUrl) {
+  server.registerResource(
+    "contextstream-openapi",
+    new ResourceTemplate("contextstream:openapi", { list: void 0 }),
     {
-      title: `Find TODOs (${promptAccessLabel("find-todos")})`,
-      description: "Scan the codebase for TODO/FIXME/HACK notes and summarize"
+      title: "ContextStream OpenAPI spec",
+      description: "Machine-readable OpenAPI from the configured API endpoint",
+      mimeType: "application/json"
     },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Scan the codebase for TODO/FIXME/HACK notes and summarize them.",
-              "",
-              ...ID_NOTES,
-              "",
-              "Use `search_pattern` with query `TODO|FIXME|HACK` (or a pattern inferred from the conversation).",
-              "Group results by file path, summarize themes, and propose a small prioritized cleanup list."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+    async () => {
+      const uri = `${apiUrl.replace(/\/$/, "")}/api-docs/openapi.json`;
+      const res = await fetch(uri);
+      const text = await res.text();
+      return wrapText("contextstream:openapi", text);
+    }
   );
-  server.registerPrompt(
-    "generate-editor-rules",
-    {
-      title: `Generate Editor Rules (${promptAccessLabel("generate-editor-rules")})`,
-      description: "Generate ContextStream AI rule files for your editor"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Generate ContextStream AI rule files for my editor.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- If you can infer the project folder path from the environment/IDE roots, use it.",
-              "- Otherwise ask me for an absolute folder path.",
-              "- Ask which editor(s) (windsurf,cursor,cline,kilo,roo,claude,aider) or default to all.",
-              "",
-              "Then call `generate_editor_rules` and confirm which files were created/updated."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+  server.registerResource(
+    "contextstream-workspaces",
+    new ResourceTemplate("contextstream:workspaces", { list: void 0 }),
+    { title: "Workspaces", description: "List of accessible workspaces" },
+    async () => {
+      const data = await client.listWorkspaces();
+      return wrapText("contextstream:workspaces", JSON.stringify(data, null, 2));
+    }
   );
-  server.registerPrompt(
-    "index-local-repo",
-    {
-      title: `Index Local Repo (${promptAccessLabel("index-local-repo")})`,
-      description: "Ingest local files into ContextStream for indexing/search"
-    },
-    async () => ({
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: [
-              "Ingest local files into ContextStream for indexing/search.",
-              "",
-              ...ID_NOTES,
-              "",
-              "First:",
-              "- Ask me for the local directory path to ingest if it is not already specified.",
-              "",
-              "Then:",
-              "- Call `projects_ingest_local` with the path (use session defaults for project, or the `project_id` returned by `session_init`).",
-              "- Explain how to monitor progress via `projects_index_status`."
-            ].join("\n")
-          }
-        }
-      ]
-    })
+  server.registerResource(
+    "contextstream-projects",
+    new ResourceTemplate("contextstream:projects/{workspaceId}", { list: void 0 }),
+    { title: "Projects for workspace", description: "Projects in the specified workspace" },
+    async (uri, { workspaceId }) => {
+      const wsId = Array.isArray(workspaceId) ? workspaceId[0] : workspaceId;
+      const data = await client.listProjects({ workspace_id: wsId });
+      return wrapText(uri.href, JSON.stringify(data, null, 2));
+    }
   );
 }
 
@@ -9633,7 +9414,6 @@ async function main() {
   const sessionManager = new SessionManager(server, client);
   registerTools(server, client, sessionManager);
   registerResources(server, client, config.apiUrl);
-  registerPrompts(server);
   console.error(`ContextStream MCP server v${VERSION} starting...`);
   console.error(`API URL: ${config.apiUrl}`);
   console.error(`Auth: ${config.apiKey ? "API Key" : config.jwt ? "JWT" : "None"}`);