@contextstream/mcp-server 0.3.27 → 0.3.28

package/README.md

@@ -20,7 +20,7 @@ No special syntax. No commands to learn. Just ask.
 
 > **Tip:** For best results, add the [recommended editor rules](https://contextstream.io/docs/quickstart) so your AI consistently calls `session_init` / `context_smart` automatically.
 
-![ContextStream in action](mcp.gif.gif)
+![ContextStream in action](compare1.gif)
 
 ## Features
 

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
@@ -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;
@@ -8510,6 +8710,304 @@ This saves ~80% tokens compared to including full chat history.`,
       };
     }
   );
+  registerTool(
+    "slack_stats",
+    {
+      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 (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) };
+    }
+  );
+  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) };
+    }
+  );
+  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) };
+    }
+  );
+  registerTool(
+    "slack_activity",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "slack_discussions",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "slack_search",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "slack_sync_users",
+    {
+      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 (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)
+      };
+    }
+  );
+  registerTool(
+    "github_stats",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "github_repos",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "github_contributors",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "github_activity",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "github_issues",
+    {
+      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 (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) };
+    }
+  );
+  registerTool(
+    "github_search",
+    {
+      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 (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) };
+    }
+  );
 }
 
 // src/resources.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextstream/mcp-server",
-  "version": "0.3.27",
+  "version": "0.3.28",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",