@contextstream/mcp-server 0.3.71 → 0.3.73

package/dist/index.js

@@ -8282,6 +8282,235 @@ function getRecommendedToolset(clientName, fromEnv) {
 }
 var detectedClientInfo = null;
 var clientDetectedFromEnv = false;
+var PROGRESSIVE_MODE = process.env.CONTEXTSTREAM_PROGRESSIVE_MODE === "true";
+var TOOL_BUNDLES = {
+  // Core bundle (~12 tools) - always enabled, essential for any session
+  core: /* @__PURE__ */ new Set([
+    "session_init",
+    "session_tools",
+    "context_smart",
+    "context_feedback",
+    "session_capture",
+    "session_capture_lesson",
+    "session_get_lessons",
+    "session_recall",
+    "session_remember",
+    "session_get_user_context",
+    "tools_enable_bundle",
+    // Meta-tool to enable other bundles
+    "auth_me",
+    "mcp_server_version"
+  ]),
+  // Session bundle (~6 tools) - extended session management
+  session: /* @__PURE__ */ new Set([
+    "session_summary",
+    "session_smart_search",
+    "session_compress",
+    "session_delta",
+    "decision_trace",
+    "generate_editor_rules"
+  ]),
+  // Memory bundle (~12 tools) - full memory CRUD operations
+  memory: /* @__PURE__ */ new Set([
+    "memory_create_event",
+    "memory_update_event",
+    "memory_delete_event",
+    "memory_list_events",
+    "memory_get_event",
+    "memory_search",
+    "memory_decisions",
+    "memory_timeline",
+    "memory_summary",
+    "memory_create_node",
+    "memory_update_node",
+    "memory_delete_node",
+    "memory_list_nodes",
+    "memory_get_node",
+    "memory_supersede_node",
+    "memory_distill_event"
+  ]),
+  // Search bundle (~4 tools) - search capabilities
+  search: /* @__PURE__ */ new Set([
+    "search_semantic",
+    "search_hybrid",
+    "search_keyword"
+  ]),
+  // Graph bundle (~9 tools) - code graph analysis
+  graph: /* @__PURE__ */ new Set([
+    "graph_related",
+    "graph_decisions",
+    "graph_path",
+    "graph_dependencies",
+    "graph_call_path",
+    "graph_impact",
+    "graph_circular_dependencies",
+    "graph_unused_code",
+    "graph_ingest"
+  ]),
+  // Workspace bundle (~4 tools) - workspace management
+  workspace: /* @__PURE__ */ new Set([
+    "workspaces_list",
+    "workspaces_get",
+    "workspace_associate",
+    "workspace_bootstrap"
+  ]),
+  // Project bundle (~10 tools) - project management and indexing
+  project: /* @__PURE__ */ new Set([
+    "projects_create",
+    "projects_update",
+    "projects_list",
+    "projects_get",
+    "projects_overview",
+    "projects_statistics",
+    "projects_index",
+    "projects_index_status",
+    "projects_files",
+    "projects_ingest_local"
+  ]),
+  // Reminders bundle (~6 tools) - reminder management
+  reminders: /* @__PURE__ */ new Set([
+    "reminders_list",
+    "reminders_active",
+    "reminders_create",
+    "reminders_snooze",
+    "reminders_complete",
+    "reminders_dismiss"
+  ]),
+  // Integrations bundle - Slack/GitHub tools (auto-hidden when not connected)
+  integrations: /* @__PURE__ */ new Set([
+    "slack_stats",
+    "slack_channels",
+    "slack_search",
+    "slack_discussions",
+    "slack_activity",
+    "slack_contributors",
+    "slack_knowledge",
+    "slack_summary",
+    "slack_sync_users",
+    "github_stats",
+    "github_repos",
+    "github_search",
+    "github_issues",
+    "github_activity",
+    "github_contributors",
+    "github_knowledge",
+    "github_summary",
+    "integrations_status",
+    "integrations_search",
+    "integrations_summary",
+    "integrations_knowledge"
+  ])
+};
+var enabledBundles = /* @__PURE__ */ new Set(["core"]);
+function isToolInEnabledBundles(toolName) {
+  for (const bundleName of enabledBundles) {
+    const bundle = TOOL_BUNDLES[bundleName];
+    if (bundle?.has(toolName)) {
+      return true;
+    }
+  }
+  return false;
+}
+function getBundleInfo() {
+  const descriptions = {
+    core: "Essential session tools (always enabled)",
+    session: "Extended session management and utilities",
+    memory: "Full memory CRUD operations",
+    search: "Semantic, hybrid, and keyword search",
+    graph: "Code graph analysis and dependencies",
+    workspace: "Workspace management",
+    project: "Project management and indexing",
+    reminders: "Reminder management",
+    integrations: "Slack and GitHub integrations"
+  };
+  return Object.entries(TOOL_BUNDLES).map(([name, tools]) => ({
+    name,
+    size: tools.size,
+    enabled: enabledBundles.has(name),
+    description: descriptions[name] || `${name} tools`
+  }));
+}
+var deferredTools = /* @__PURE__ */ new Map();
+var ROUTER_MODE = process.env.CONTEXTSTREAM_ROUTER_MODE === "true";
+var operationsRegistry = /* @__PURE__ */ new Map();
+function inferOperationCategory(name) {
+  if (name.startsWith("session_") || name.startsWith("context_")) return "Session";
+  if (name.startsWith("memory_")) return "Memory";
+  if (name.startsWith("search_")) return "Search";
+  if (name.startsWith("graph_")) return "Graph";
+  if (name.startsWith("workspace")) return "Workspace";
+  if (name.startsWith("project")) return "Project";
+  if (name.startsWith("reminder")) return "Reminders";
+  if (name.startsWith("slack_") || name.startsWith("github_") || name.startsWith("integration")) return "Integrations";
+  if (name.startsWith("ai_")) return "AI";
+  if (name === "auth_me" || name === "mcp_server_version" || name === "generate_editor_rules") return "Utility";
+  if (name === "tools_enable_bundle" || name === "contextstream" || name === "contextstream_help") return "Meta";
+  return "Other";
+}
+function getOperationCatalog(category) {
+  const ops = {};
+  for (const [name, config] of operationsRegistry) {
+    const cat = config.category;
+    if (category && cat.toLowerCase() !== category.toLowerCase()) continue;
+    if (!ops[cat]) ops[cat] = [];
+    ops[cat].push(name);
+  }
+  const lines = [];
+  for (const [cat, names] of Object.entries(ops).sort()) {
+    lines.push(`${cat}: ${names.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function getOperationSchema(name) {
+  const op = operationsRegistry.get(name);
+  if (!op) return null;
+  const zodSchema = op.inputSchema;
+  try {
+    const shape = zodSchema?._def?.shape?.() || zodSchema?.shape || {};
+    const properties = {};
+    const required = [];
+    for (const [key, field] of Object.entries(shape)) {
+      const f = field;
+      const isOptional = f?._def?.typeName === "ZodOptional" || f?.isOptional?.();
+      const innerType = isOptional ? f?._def?.innerType : f;
+      const typeName = innerType?._def?.typeName || "unknown";
+      const description = f?._def?.description || innerType?._def?.description;
+      let type = "string";
+      if (typeName === "ZodNumber") type = "number";
+      else if (typeName === "ZodBoolean") type = "boolean";
+      else if (typeName === "ZodArray") type = "array";
+      else if (typeName === "ZodObject") type = "object";
+      else if (typeName === "ZodEnum") type = "enum";
+      properties[key] = { type };
+      if (description) properties[key].description = description;
+      if (typeName === "ZodEnum") {
+        properties[key].enum = innerType?._def?.values;
+      }
+      if (!isOptional) required.push(key);
+    }
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      }
+    };
+  } catch {
+    return {
+      name: op.name,
+      title: op.title,
+      description: op.description,
+      category: op.category,
+      schema: { type: "object" }
+    };
+  }
+}
+var OUTPUT_FORMAT = process.env.CONTEXTSTREAM_OUTPUT_FORMAT || "compact";
+var COMPACT_OUTPUT = OUTPUT_FORMAT === "compact";
 var TOOLSET_ALIASES = {
   // Light mode - minimal, fastest
   light: LIGHT_TOOLSET,
@@ -8344,8 +8573,9 @@ function resolveToolFilter() {
   console.error(`[ContextStream] Unknown CONTEXTSTREAM_TOOLSET "${toolsetRaw}". Using standard toolset.`);
   return { allowlist: STANDARD_TOOLSET, source: "standard", autoDetected: false };
 }
-function formatContent(data) {
-  return JSON.stringify(data, null, 2);
+function formatContent(data, forceFormat) {
+  const usePretty = forceFormat === "pretty" || !forceFormat && !COMPACT_OUTPUT;
+  return usePretty ? JSON.stringify(data, null, 2) : JSON.stringify(data);
 }
 function toStructured(data) {
   if (data && typeof data === "object" && !Array.isArray(data)) {
@@ -8478,6 +8708,21 @@ function registerTools(server, client, sessionManager) {
   } else {
     console.error("[ContextStream] Schema mode: full (set CONTEXTSTREAM_SCHEMA_MODE=compact to reduce token overhead)");
   }
+  if (PROGRESSIVE_MODE) {
+    const coreBundle = TOOL_BUNDLES.core;
+    console.error(`[ContextStream] Progressive mode: ENABLED (starting with ${coreBundle.size} core tools)`);
+    console.error("[ContextStream] Use tools_enable_bundle to unlock additional tool bundles dynamically.");
+  }
+  if (ROUTER_MODE) {
+    console.error("[ContextStream] Router mode: ENABLED (all operations accessed via contextstream/contextstream_help)");
+    console.error("[ContextStream] Only 2 tools registered. Use contextstream_help to see available operations.");
+  }
+  if (COMPACT_OUTPUT) {
+    console.error("[ContextStream] Output format: COMPACT (minified JSON, ~30% fewer tokens per response)");
+  } else {
+    console.error("[ContextStream] Output format: pretty (set CONTEXTSTREAM_OUTPUT_FORMAT=compact for fewer tokens)");
+  }
+  let serverRef = server;
   const defaultProTools = /* @__PURE__ */ new Set([
     // AI endpoints (typically paid/credit-metered)
     "ai_context",
@@ -8771,13 +9016,7 @@ function registerTools(server, client, sessionManager) {
       });
     };
   }
-  function registerTool(name, config, handler) {
-    if (toolAllowlist && !toolAllowlist.has(name)) {
-      return;
-    }
-    if (!shouldRegisterIntegrationTool(name)) {
-      return;
-    }
+  function actuallyRegisterTool(name, config, handler) {
     const accessLabel = getToolAccessLabel(name);
     const showUpgrade = accessLabel !== "Free";
     let finalDescription;
@@ -8834,12 +9073,73 @@ Upgrade: ${upgradeUrl2}` : "";
         };
       }
     };
-    server.registerTool(
+    serverRef.registerTool(
       name,
       annotatedConfig,
       wrapWithAutoContext(name, safeHandler)
     );
   }
+  function enableBundle(bundleName) {
+    if (enabledBundles.has(bundleName)) {
+      return { success: true, message: `Bundle '${bundleName}' is already enabled.`, toolsEnabled: 0 };
+    }
+    const bundle = TOOL_BUNDLES[bundleName];
+    if (!bundle) {
+      return { success: false, message: `Unknown bundle '${bundleName}'. Available: ${Object.keys(TOOL_BUNDLES).join(", ")}`, toolsEnabled: 0 };
+    }
+    enabledBundles.add(bundleName);
+    let toolsEnabled = 0;
+    for (const toolName of bundle) {
+      const deferred = deferredTools.get(toolName);
+      if (deferred) {
+        actuallyRegisterTool(deferred.name, deferred.config, deferred.handler);
+        deferredTools.delete(toolName);
+        toolsEnabled++;
+      }
+    }
+    try {
+      const lowLevelServer = serverRef;
+      lowLevelServer.sendToolsListChanged?.();
+    } catch {
+    }
+    console.error(`[ContextStream] Bundle '${bundleName}' enabled with ${toolsEnabled} tools.`);
+    return { success: true, message: `Enabled bundle '${bundleName}' with ${toolsEnabled} tools.`, toolsEnabled };
+  }
+  const ROUTER_DIRECT_TOOLS = /* @__PURE__ */ new Set(["contextstream", "contextstream_help"]);
+  function registerTool(name, config, handler) {
+    if (toolAllowlist && !toolAllowlist.has(name)) {
+      if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+        operationsRegistry.set(name, {
+          name,
+          title: config.title,
+          description: config.description,
+          inputSchema: config.inputSchema,
+          handler,
+          category: inferOperationCategory(name)
+        });
+      }
+      return;
+    }
+    if (!shouldRegisterIntegrationTool(name)) {
+      return;
+    }
+    if (ROUTER_MODE && !ROUTER_DIRECT_TOOLS.has(name)) {
+      operationsRegistry.set(name, {
+        name,
+        title: config.title,
+        description: config.description,
+        inputSchema: config.inputSchema,
+        handler,
+        category: inferOperationCategory(name)
+      });
+      return;
+    }
+    if (PROGRESSIVE_MODE && !isToolInEnabledBundles(name)) {
+      deferredTools.set(name, { name, config, handler });
+      return;
+    }
+    actuallyRegisterTool(name, config, handler);
+  }
   function errorResult(text) {
     return {
       content: [{ type: "text", text }],
@@ -8909,6 +9209,187 @@ Upgrade: ${upgradeUrl2}` : "";
       return { content: [{ type: "text", text: formatContent(result) }], structuredContent: toStructured(result) };
     }
   );
+  registerTool(
+    "tools_enable_bundle",
+    {
+      title: "Enable tool bundle",
+      description: `Enable a bundle of related tools dynamically. Only available when CONTEXTSTREAM_PROGRESSIVE_MODE=true.
+
+Available bundles:
+- session: Extended session management (~6 tools)
+- memory: Full memory CRUD operations (~16 tools)
+- search: Semantic, hybrid, and keyword search (~3 tools)
+- graph: Code graph analysis and dependencies (~9 tools)
+- workspace: Workspace management (~4 tools)
+- project: Project management and indexing (~10 tools)
+- reminders: Reminder management (~6 tools)
+- integrations: Slack and GitHub integrations (~21 tools)
+
+Example: Enable memory tools before using memory_create_event.`,
+      inputSchema: external_exports.object({
+        bundle: external_exports.enum(["session", "memory", "search", "graph", "workspace", "project", "reminders", "integrations"]).describe("Name of the bundle to enable"),
+        list_bundles: external_exports.boolean().optional().describe("If true, list all available bundles and their status")
+      })
+    },
+    async (input) => {
+      if (input.list_bundles) {
+        const bundles = getBundleInfo();
+        const result2 = {
+          progressive_mode: PROGRESSIVE_MODE,
+          bundles,
+          hint: PROGRESSIVE_MODE ? "Call tools_enable_bundle with a bundle name to enable additional tools." : "Progressive mode is disabled. All tools from your toolset are already available."
+        };
+        return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+      }
+      if (!PROGRESSIVE_MODE) {
+        const result2 = {
+          success: true,
+          message: `Progressive mode is disabled. All tools from your toolset are already available. Bundle '${input.bundle}' tools are accessible.`,
+          progressive_mode: false
+        };
+        return { content: [{ type: "text", text: formatContent(result2) }], structuredContent: toStructured(result2) };
+      }
+      const result = enableBundle(input.bundle);
+      const response = {
+        ...result,
+        progressive_mode: true,
+        enabled_bundles: Array.from(enabledBundles),
+        hint: result.success && result.toolsEnabled > 0 ? "New tools are now available. The client should refresh its tool list." : void 0
+      };
+      return { content: [{ type: "text", text: formatContent(response) }], structuredContent: toStructured(response) };
+    }
+  );
+  if (ROUTER_MODE) {
+    serverRef.registerTool(
+      "contextstream",
+      {
+        title: "ContextStream Operation",
+        description: `Execute any ContextStream operation. Use contextstream_help to see available operations.
+
+Example: contextstream({ op: "session_init", args: { folder_path: "/path/to/project" } })
+
+This single tool replaces 50+ individual tools, dramatically reducing token overhead.
+All ContextStream functionality is accessible through this dispatcher.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name (e.g., session_init, memory_create_event)" },
+            args: { type: "object", description: "Operation arguments (varies by operation)" }
+          },
+          required: ["op"]
+        },
+        annotations: {
+          readOnlyHint: false,
+          destructiveHint: false,
+          idempotentHint: false,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        const opName = input.op;
+        const operation = operationsRegistry.get(opName);
+        if (!operation) {
+          const available = getOperationCatalog();
+          return {
+            content: [{
+              type: "text",
+              text: `Unknown operation: ${opName}
+
+Available operations:
+${available}
+
+Use contextstream_help({ op: "operation_name" }) for details.`
+            }],
+            isError: true
+          };
+        }
+        const args = input.args || {};
+        const parsed = operation.inputSchema.safeParse(args);
+        if (!parsed.success) {
+          const schema = getOperationSchema(opName);
+          return {
+            content: [{
+              type: "text",
+              text: `Invalid arguments for ${opName}: ${parsed.error.message}
+
+Expected schema:
+${JSON.stringify(schema?.schema || {}, null, 2)}`
+            }],
+            isError: true
+          };
+        }
+        try {
+          return await operation.handler(parsed.data);
+        } catch (error) {
+          return {
+            content: [{
+              type: "text",
+              text: `Error executing ${opName}: ${error?.message || String(error)}`
+            }],
+            isError: true
+          };
+        }
+      }
+    );
+    serverRef.registerTool(
+      "contextstream_help",
+      {
+        title: "ContextStream Help",
+        description: `Get help on available ContextStream operations or schema for a specific operation.
+
+Examples:
+- contextstream_help({}) - List all operations by category
+- contextstream_help({ op: "session_init" }) - Get schema for session_init
+- contextstream_help({ category: "Memory" }) - List memory operations only`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            op: { type: "string", description: "Operation name to get schema for" },
+            category: { type: "string", description: "Category to filter (Session, Memory, Search, Graph, etc.)" }
+          }
+        },
+        annotations: {
+          readOnlyHint: true,
+          destructiveHint: false,
+          idempotentHint: true,
+          openWorldHint: false
+        }
+      },
+      async (input) => {
+        if (input.op) {
+          const schema = getOperationSchema(input.op);
+          if (!schema) {
+            return {
+              content: [{
+                type: "text",
+                text: `Unknown operation: ${input.op}
+
+Use contextstream_help({}) to see available operations.`
+              }],
+              isError: true
+            };
+          }
+          return {
+            content: [{ type: "text", text: JSON.stringify(schema, null, 2) }],
+            structuredContent: schema
+          };
+        }
+        const catalog = getOperationCatalog(input.category);
+        const result = {
+          router_mode: true,
+          total_operations: operationsRegistry.size,
+          categories: catalog,
+          usage: 'Call contextstream({ op: "operation_name", args: {...} }) to execute an operation.',
+          hint: 'Use contextstream_help({ op: "operation_name" }) to see the schema for a specific operation.'
+        };
+        return {
+          content: [{ type: "text", text: formatContent(result) }],
+          structuredContent: toStructured(result)
+        };
+      }
+    );
+    console.error(`[ContextStream] Router mode: Registered 2 meta-tools, ${operationsRegistry.size} operations available via dispatcher.`);
+  }
   registerTool(
     "workspaces_list",
     {
@@ -10110,9 +10591,26 @@ Memory: events(crud) nodes(knowledge) search(find) decisions(choices)`,
     async (input) => {
       const format = input.format || "grouped";
       const catalog = generateToolCatalog(format, input.category);
+      let bundleInfo = "";
+      if (PROGRESSIVE_MODE) {
+        const bundles = getBundleInfo();
+        const enabledList = bundles.filter((b) => b.enabled).map((b) => b.name).join(", ");
+        const availableList = bundles.filter((b) => !b.enabled).map((b) => `${b.name}(${b.size})`).join(", ");
+        bundleInfo = `
+
+[Progressive Mode]
+Enabled: ${enabledList}
+Available: ${availableList}
+Use tools_enable_bundle to unlock more tools.`;
+      }
       return {
-        content: [{ type: "text", text: catalog }],
-        structuredContent: { format, catalog }
+        content: [{ type: "text", text: catalog + bundleInfo }],
+        structuredContent: {
+          format,
+          catalog,
+          progressive_mode: PROGRESSIVE_MODE,
+          bundles: PROGRESSIVE_MODE ? getBundleInfo() : void 0
+        }
       };
     }
   );
@@ -14278,6 +14776,9 @@ Environment variables:
   CONTEXTSTREAM_AUTO_TOOLSET  Auto-detect client and adjust toolset (default: false)
   CONTEXTSTREAM_AUTO_HIDE_INTEGRATIONS  Auto-hide Slack/GitHub tools when not connected (default: true)
   CONTEXTSTREAM_SCHEMA_MODE   Schema verbosity: compact|full (default: full, compact reduces tokens)
+  CONTEXTSTREAM_PROGRESSIVE_MODE  Progressive disclosure: true|false (default: false, starts with ~13 core tools)
+  CONTEXTSTREAM_ROUTER_MODE   Router pattern: true|false (default: false, exposes only 2 meta-tools)
+  CONTEXTSTREAM_OUTPUT_FORMAT Output verbosity: compact|pretty (default: compact, ~30% fewer tokens)
   CONTEXTSTREAM_PRO_TOOLS     Optional comma-separated PRO tool names (default: AI tools)
   CONTEXTSTREAM_UPGRADE_URL   Optional upgrade URL shown for PRO tools on Free plan
   CONTEXTSTREAM_ENABLE_PROMPTS Enable MCP prompts list (default: true)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextstream/mcp-server",
   "mcpName": "io.github.contextstreamio/mcp-server",
-  "version": "0.3.71",
+  "version": "0.3.73",
   "description": "MCP server exposing ContextStream public API - code context, memory, search, and AI tools for developers",
   "type": "module",
   "license": "MIT",